release 7 (a744da0941)

CHANGELOG.md

@@ -3,6 +3,46 @@
 Releases are identified by date. The Docker distribution (branch `distribution`, Hugging Face `bryceweiner/fly-trader`)
 ships signed releases built from this development line.
 
+## 2026-10-18, release 7: A live buy costs what its paper twin does, and the fly learns again
+
+Published to Hugging Face as signed release 7. Fly #157 and selector #154 are unchanged, and so are the definitions they
+were judged on: no model, seed or infrastructure file changes.
+
+### Upgrading
+
+- **Nothing to do on a Docker install:** its updater installs this release within the hour, as usual.
+- **A server on the host updater** (`deploy/fly_update.py`) holds this code release for 24 hours, or applies it at once
+  with `fly_update.py approve 7`.
+- **New columns are added on start:** `deposit_sol` and `deposit_refunded` on `positions`.
+- **If your fly's learning froze** (the console's model page says learning is frozen), lift it with Resume learning once
+  this release runs.
+
+### Live money
+
+- **A live buy costs what its paper twin does.**
+  - The ~0.0015 SOL that a first buy of a token pays to open its token account is a deposit. The account's close
+    returns it.
+  - It was booked as part of the buy, so live buys looked 1–3 % bigger than paper and their entry prices 1–3 % higher.
+  - The deposit is now kept apart from the buy and counted in live wealth until the close returns it. Only the close's
+    fee is the position's.
+
+### The fly
+
+- **It learns again, and one strategy's trouble no longer stops the other's learning.**
+  - On 2026-10-13 the rollback checks froze all of the fly's learning after rolling ev back three times in three days.
+  - ev cannot learn (its learning rate is 0), so there was nothing to roll back. The IC check had tripped only because
+    the selector's own ev ranking had a bad day (IC −0.10 to −0.13).
+  - Capitulation, which was learning, stopped too. Five days of decay then erased what it had learned, and the
+    re-bootstrap the freeze asked for never ran.
+  - The checks now judge only what learning did. A strategy that has learned nothing trips none. The IC check compares
+    the fly with its frozen copy on the same rows instead of with zero, and the replays count it the same way.
+  - Reaching the rollback limit freezes that strategy's learning only.
+- **One fly's operator commands reach it.**
+  - The Solana and Robinhood Chain books share one memory. Before, whichever book's minute ran first took a pause,
+    resume or rollback, and a resume could reach only the book that did not need it.
+  - The Robinhood Chain book also kept learning into the shared memory while the Solana book was frozen.
+  - Only the Solana book takes these commands now, and the Robinhood Chain book's learning follows its pause and freezes.
+
 ## 2026-10-18, release 6: A restart never holds a sale back, and Kalshi orders go first
 
 Published to Hugging Face as signed release 6. Fly #157 and selector #154 are unchanged, and so are the definitions they

fly_trader/agent/fly_live.py

@@ -22,6 +22,7 @@ The paper book ``paper_fly`` keeps running as the mirror. Only after the handove
   live trades, the mean return per trade trailing the paper mirror's same decisions by more than ``GAP_MAX`` pauses
   entries and raises an alert;
 - between minutes (``idle``), never in front of an order: the wealth mark — wallet SOL + open positions net of exit cost
+  + the token accounts' deposits not yet returned (a first buy's rent, ledger.deposits_held)
   → ``wealth_marks`` (book 'live'), read once the worker has nothing queued or in flight (a balance read beside a
   booking counts that trade twice or not at all) and not just before a boundary; the kill switch on its own peak; and
   every ``SWEEP_S``, mid-minute, the written-off tokens are swept (what they fetch is booked onto their dead-bag).
@@ -251,17 +252,17 @@ class LiveMirror:
         if mark is None:
             return None
         rebase = rails.kill_rebase_at(conn)
-        lamports, gross_v, exit_cost, exposure, n_open = mark
-        sol_now = lamports / config.LAMPORTS_PER_SOL; wealth = sol_now + gross_v - exit_cost
+        lamports, gross_v, exit_cost, exposure, n_open, deposits = mark
+        sol_now = lamports / config.LAMPORTS_PER_SOL; wealth = sol_now + deposits + gross_v - exit_cost
         pk = conn.execute("SELECT max(wealth) AS pk FROM wealth_marks WHERE book = %s AND (%s::timestamptz IS NULL OR ts > %s)",
                           (BOOK, rebase, rebase)).fetchone(); peak = max(float(pk["pk"] or 0.0), wealth)
         conn.execute("INSERT INTO wealth_marks (beat_id, book, ts, sol_free, positions_value, exit_cost, wealth, peak, drawdown, exposure, n_open) VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s) "
                      "ON CONFLICT (beat_id, book) DO NOTHING",
-                     (beat_id, BOOK, m1, sol_now, gross_v - exit_cost, exit_cost, wealth, peak, (1.0 - wealth / peak) if peak > 0 else 0.0, exposure, n_open))
+                     (beat_id, BOOK, m1, sol_now, deposits + gross_v - exit_cost, exit_cost, wealth, peak, (1.0 - wealth / peak) if peak > 0 else 0.0, exposure, n_open))
         if config.VAULT_ENABLED:                     # deposits, withdrawals and payouts are not performance
             from ..vault import nav as vault_nav, payout as vault_payout     # trading wallet + treasury are one book: a top-up or sweep is no loss
-            vault_nav.mark(conn, m1, lamports + vault_payout.cached_balance(), int(round(gross_v * config.LAMPORTS_PER_SOL)),
-                           int(round(exit_cost * config.LAMPORTS_PER_SOL)))
+            vault_nav.mark(conn, m1, lamports + int(round(deposits * config.LAMPORTS_PER_SOL)) + vault_payout.cached_balance(),
+                           int(round(gross_v * config.LAMPORTS_PER_SOL)), int(round(exit_cost * config.LAMPORTS_PER_SOL)))
             ix = vault_nav.status(conn, since=rebase)
             killed = rails.check_drawdown(conn, ix["value"], ix["peak"], unit="index")
         else:
@@ -271,7 +272,8 @@ class LiveMirror:
         return self.last_mark
 
     def _mark(self, conn, ctx) -> tuple | None:
-        """(wallet lamports, open positions' gross value, their exit cost, exposure at cost, open positions), read while no
+        """(wallet lamports, open positions' gross value, their exit cost, exposure at cost, open positions, the token
+        accounts' deposits held in SOL), read while no
         swap is between its fill and its booking (the worker's ``busy``): a balance read beside a booking in progress
         counts that trade twice or not at all. None when the worker stayed busy ``MARK_WAIT_S``."""
         if not self.worker.busy.acquire(timeout=MARK_WAIT_S):
@@ -288,7 +290,7 @@ class LiveMirror:
                 gross = int(p["qty"]) / 10 ** int(p.get("decimals") or 6) * px
                 gross_v += gross; exposure += float(p["cost_sol"])
                 exit_cost += gross * exit_cost_fraction(gross, ctx.resqs.get(p["mint"]) or ctx.last_resq(p["mint"]), ctx.mcap(p["mint"], px), p.get("program_label"), ctx.fee(p["mint"]))
-            return lamports, gross_v, exit_cost, exposure, len(opens)
+            return lamports, gross_v, exit_cost, exposure, len(opens), ledger.deposits_held(conn, BOOK)
         finally:
             self.worker.busy.release()
 

fly_trader/agent/fly_session.py

@@ -21,9 +21,10 @@ first (CLAUDE.md): ``on_minute`` runs before any other book's minute, ``after_mi
    (the bootstrap, D = 0) from their scores of the minutes resolved in the last seven days (``train/fly_calibrate.py``).
 
 Hourly: learning statistics (``fly_updates``), a snapshot of the plastic state (kind 'fly_plastic'; hourly for 7 days,
-then one per day), the rollback checks (``train/fly_governance.py``; a rollback restores the newest good snapshot at
-least a day old, or D = 0, pauses the checks a day, and the third within 7 days freezes learning and requests a
-re-bootstrap), and the handover (``HANDOVER_DAYS`` of racing, at least ``HANDOVER_MIN_TRADES`` trades, realized P&L
+then one per day), the rollback checks (``train/fly_governance.py``: they judge what learning did, against the frozen
+shadow; a rollback restores the newest good snapshot at least a day old, or D = 0, pauses the checks a day, and the
+third within 7 days freezes that strategy's learning -- not the other strategies' -- and requests a re-bootstrap), and
+the handover (``HANDOVER_DAYS`` of racing, at least ``HANDOVER_MIN_TRADES`` trades, realized P&L
 at least the selector's). The state file ``data/brain/plastic/state.pt`` is written atomically every minute, before
 tags are marked resolved: on restart, pending tags at or before its watermark count as applied.
 """
@@ -199,6 +200,7 @@ class FlyBook:
         self.lines = {"plastic": dict(own), "frozen": dict(own)}
         self.sizing = {"plastic": {k: list(v) for k, v in own_s.items()}, "frozen": {k: list(v) for k, v in own_s.items()}}
         self.applied_through = -math.inf; self.learning_frozen = False; self.checks_paused_until = {k: 0.0 for k in self.names}
+        self.frozen: list[str] = []          # strategies whose learning the rollback limit froze (learning_frozen: the operator's pause, all)
         self.race_started_at: float | None = None; self.last_day: int | None = None; self.last_hour: int | None = None
         self.rollbacks: dict = {k: [] for k in self.names}; self.nu_set = False; self.hour_stats = self._empty_stats(); self.last_checks: dict = {}
         s = self._read_state()
@@ -213,6 +215,7 @@ class FlyBook:
             self.nu_set = True
             self.lines, self.sizing = s["lines"], s["sizing"]
             self.applied_through, self.learning_frozen, self.checks_paused_until = s["applied_through"], s["learning_frozen"], s["checks_paused_until"]
+            self.frozen = [k for k in s.get("frozen") or [] if k in self.names]
             self.race_started_at, self.last_day, self.last_hour, self.rollbacks = s["race_started_at"], s["last_day"], s["last_hour"], s["rollbacks"]
         elif s:
             self.race_started_at = s.get("race_started_at")        # a new bootstrap keeps racing the same book
@@ -309,7 +312,7 @@ class FlyBook:
 
     def _state(self) -> dict:
         return {"bootstrap_id": self.boot_id, "cfg": self.cfg, "score": config.FLY_SCORE, "bank": self.bank.state() if self.brain is None else None, "lines": self.lines, "sizing": self.sizing,
-                "applied_through": self.applied_through, "learning_frozen": self.learning_frozen, "checks_paused_until": self.checks_paused_until,
+                "applied_through": self.applied_through, "learning_frozen": self.learning_frozen, "frozen": self.frozen, "checks_paused_until": self.checks_paused_until,
                 "race_started_at": self.race_started_at, "last_day": self.last_day, "last_hour": self.last_hour, "rollbacks": self.rollbacks,
                 "saved_at": time.time()}
 
@@ -453,7 +456,9 @@ class FlyBook:
         out = {"minute": ctx.m1.isoformat(), "eligible": len(ctx.mints), "picks": ph["picks"], "lines": self.lines["plastic"], "frozen_lines": self.lines["frozen"],
                "line": self.lines["plastic"][self.names[0]], "frozen_line": self.lines["frozen"][self.names[0]],
                "drift": max(drift.values()) if drift else 0.0, "drift_by_strategy": drift, "pending": len(self.pending), "learned": learned,
-               "learning_frozen": self.learning_frozen, "channels": self.cfg, "holds_min": {k: v / 60.0 for k, v in self.holds.items()}, "bootstrap": self.boot_id,
+               "learning_frozen": (self.brain or self).learning_frozen, "frozen_strategies": (self.brain or self).frozen, "channels": self.cfg,
+               "holds_min": {k: v / 60.0 for k, v in self.holds.items()},
+               "bootstrap": self.boot_id,
                "device": str(self.fly.net.dev)}
         if st is not None:
             out.update({k: v for k, v in st.items() if k != "entries"}); out["stage"] = "trading"
@@ -613,10 +618,17 @@ class FlyBook:
         return stats
 
     def _teach(self, tags, r: np.ndarray, now: float, pathway: str) -> dict | None:
-        """One update of ``pathway`` (None while learning is frozen: the memory only decays)."""
-        if self.learning_frozen:
+        """One update of ``pathway`` by the tags of strategies that may learn (None when none may: the memory only decays).
+        A strategy the rollback limit froze keeps decaying but learns nothing; the operator's pause freezes all. Another
+        chain's book teaches the Solana book's memory, so that book's freezes are the ones that hold."""
+        owner = self.brain if self.brain is not None else self
+        held = [self.names.index(k) for k in owner.frozen if k in self.names]
+        keep = ~np.isin(np.asarray(tags.s), held) if held else np.ones(len(tags), bool)
+        if owner.learning_frozen or not keep.any():
             self.bank.decay_to(now)
             return None
+        if not keep.all():
+            tags, r = tags.subset(keep), np.asarray(r)[keep]
         return self.bank.update(tags, torch.tensor(r, dtype=torch.float32), now, pathway=pathway)
 
     def _teach_fill(self, tags, res: np.ndarray, now: float, stats: dict) -> None:
@@ -839,7 +851,7 @@ class FlyBook:
                 H = self.holds[name]; sc = g("score") - np.nan_to_num(g("fill_score"))
                 rp = gov.picks_returns(ts, mint, H, sc, g("line"), lab); rf = gov.picks_returns(ts, mint, H, g("frozen_score"), g("frozen_line"), lab)
                 recent = ts + H + LABEL_LAG_S > now - gov.IC_HOURS * 3600.0
-                out[name] = gov.check((rp, rf), (sc[recent], lab[recent]), self._drift(j))
+                out[name] = gov.check((rp, rf), (sc[recent], lab[recent]), self._drift(j), ic_frozen_rows=(g("frozen_score")[recent], lab[recent]))
             else:
                 out[name] = gov.check(None, None, self._drift(j))
         return out
@@ -857,7 +869,7 @@ class FlyBook:
             a = np.array([r["fill_score"] for r in rows], dtype=np.float64); b = np.array([r["fill"] for r in rows], dtype=np.float64)
             ic = float(np.corrcoef(a, b)[0, 1]) if len(rows) >= 3 and a.std() > 0 and b.std() > 0 else None
             out[name] = {"n": len(rows), "ic": ic, "drift": float(self.bank.drift(j, pathway="fill")[0])}
-            if len(rows) >= FILL_IC_MIN and ic is not None and ic < 0 and not self.learning_frozen:
+            if len(rows) >= FILL_IC_MIN and ic is not None and ic < 0 and not self.learning_frozen and name not in self.frozen:
                 self.bank.reset_columns(self.bank.fill[j]); out[name]["reset"] = True
                 record_event("warning", "fly", f"{name} fill pathway back to its bootstrap: its fill predictions ran against the fills (IC {ic:+.2f} over {len(rows)})", out[name])
         return out
@@ -879,7 +891,7 @@ class FlyBook:
         good = not any(c["triggers"] for c in checks.values())
         sid = self._snapshot(conn, now, good, checks)
         for name, c in checks.items():
-            if c["triggers"] and now >= self.checks_paused_until.get(name, 0.0) and not self.learning_frozen:
+            if c["triggers"] and now >= self.checks_paused_until.get(name, 0.0) and not self.learning_frozen and name not in self.frozen:
                 self._rollback(conn, now, c, sid, name=name)
         self._prune(conn, now)
         activity.prune(activity_dir(), now - activity.KEEP_S)
@@ -895,7 +907,11 @@ class FlyBook:
                                 (self.run_id, str(path), json.dumps(note, default=str))).fetchone()["id"])
 
     def _commands(self, conn, now: float) -> None:
-        """Operator commands from the console (``send_command``): pause / resume learning, roll back now."""
+        """Operator commands from the console (``send_command``): pause / resume learning, roll back now. They act on the
+        memory, which another chain's book shares with the Solana book: only the Solana book takes them (one key: whichever
+        book's minute ran first used to take a command, and a resume reached only the book that did not need it)."""
+        if self.brain is not None:
+            return
         r = conn.execute("SELECT value FROM ui_settings WHERE key = %s", (COMMAND_KEY,)).fetchone()
         if not r or not r["value"]:
             return
@@ -912,7 +928,7 @@ class FlyBook:
         if cmd == "pause":
             self.learning_frozen = True; record_event("info", "fly", "learning paused by the operator")
         elif cmd == "resume":
-            self.learning_frozen = False; self.rollbacks = {}; record_event("info", "fly", "learning resumed by the operator")
+            self.learning_frozen = False; self.frozen = []; self.rollbacks = {}; record_event("info", "fly", "learning resumed by the operator")
         elif cmd == "rollback":
             for j, name in enumerate(self.names):
                 self._rollback(conn, now, {"triggers": ["operator"], "drift": self._drift(j)}, None, count=False, name=name)
@@ -940,10 +956,11 @@ class FlyBook:
                      (f"{name}: " + ", ".join(checks["triggers"]), json.dumps(checks, default=str), from_sid, target["id"] if target is not None else None))
         record_event("warning", "fly", f"{name} channel rolled back ({', '.join(checks['triggers'])})", {"to_snapshot": target["id"] if target is not None else "bootstrap (D = 0)", "checks": checks})
         if count and len(self.rollbacks[name]) >= ROLLBACK_LIMIT:
-            self.learning_frozen = True
+            self.frozen = sorted(set(self.frozen) | {name})       # this strategy's learning only: the others keep learning
             from ..train import pipeline
             pipeline.request_run(fly=True, reason=f"{name}: {len(self.rollbacks[name])} rollbacks in 7 days")
-            record_event("error", "fly", f"learning frozen after {len(self.rollbacks[name])} {name} rollbacks in 7 days; re-bootstrap requested", {"rollbacks": self.rollbacks})
+            record_event("error", "fly", f"{name} learning frozen after {len(self.rollbacks[name])} rollbacks in 7 days; re-bootstrap requested",
+                         {"rollbacks": self.rollbacks, "frozen": self.frozen})
 
     def _prune(self, conn, now: float) -> None:
         rows = conn.execute("SELECT id, path, ts FROM brain_snapshots WHERE kind = 'fly_plastic' AND ts < %s ORDER BY ts DESC",

fly_trader/chain/balances.py

@@ -19,25 +19,30 @@ class Snapshot:
     tokens: dict[str, int]
     ts: datetime
     decimals: dict[str, int] = field(default_factory=dict)
+    deposits: dict[str, int] = field(default_factory=dict)   # lamports held by the wallet's token accounts of each mint (their rent)
 
     def token(self, mint: str) -> int:
         return int(self.tokens.get(mint, 0))
 
     def to_json(self) -> dict:
         return {"lamports": int(self.lamports), "tokens": {m: int(a) for m, a in self.tokens.items()},
-                "decimals": {m: int(d) for m, d in self.decimals.items()}, "ts": self.ts.isoformat()}
+                "decimals": {m: int(d) for m, d in self.decimals.items()}, "deposits": {m: int(v) for m, v in self.deposits.items()},
+                "ts": self.ts.isoformat()}
 
 
 def snapshot_balances(rpc, pubkey) -> Snapshot:
     lamports = int(rpc.get_balance(str(pubkey)))
     tokens: dict[str, int] = {}
     decimals: dict[str, int] = {}
+    deposits: dict[str, int] = {}
     for acct in rpc.get_token_accounts_by_owner(str(pubkey)):
         mint = acct["mint"]
         tokens[mint] = tokens.get(mint, 0) + int(acct["amount"])
         if acct.get("decimals") is not None:
             decimals[mint] = int(acct["decimals"])
-    return Snapshot(lamports=lamports, tokens=tokens, ts=config.utcnow(), decimals=decimals)
+        if not acct.get("is_native"):                    # a wrapped-SOL account's lamports are SOL, not a deposit
+            deposits[mint] = deposits.get(mint, 0) + int(acct.get("lamports") or 0)
+    return Snapshot(lamports=lamports, tokens=tokens, ts=config.utcnow(), decimals=decimals, deposits=deposits)
 
 
 def compute_delta(pre: Snapshot, post: Snapshot) -> dict:

fly_trader/db/schema.py

@@ -131,6 +131,9 @@ BASE_DDL: list[str] = [
         realized_sol double precision, fees_sol double precision NOT NULL DEFAULT 0,
         status text NOT NULL DEFAULT 'open', forced_exit_kind text, last_swap_ts timestamptz, satiety double precision NOT NULL DEFAULT 0)""",
     "CREATE UNIQUE INDEX IF NOT EXISTS positions_open_uniq ON positions (book, mint) WHERE status = 'open'",
+    # a live buy's token-account rent (the account's close returns it): a deposit kept apart from the position's cost
+    "ALTER TABLE positions ADD COLUMN IF NOT EXISTS deposit_sol double precision",
+    "ALTER TABLE positions ADD COLUMN IF NOT EXISTS deposit_refunded boolean NOT NULL DEFAULT false",
     "CREATE INDEX IF NOT EXISTS positions_book_status_idx ON positions (book, status)",
     """CREATE TABLE IF NOT EXISTS wealth_marks (
         beat_id bigint NOT NULL, book text NOT NULL, ts timestamptz NOT NULL DEFAULT now(),

fly_trader/execution/broker_live.py

@@ -45,6 +45,7 @@ from ..signer.policy import EXCLUDE_ROUTERS, PolicyError
 from ..db.apilog import record_event
 from ..db.connection import connect, transaction
 from ..logging_setup import scrub
+from . import ledger
 
 log = logging.getLogger(__name__)
 
@@ -73,9 +74,10 @@ class FillResult:
     code: int | None
     error: str | None
     token_delta: int
-    lamports_delta: int
+    lamports_delta: int               # the trade's SOL: the wallet's change less what went into (or came back from) the mint's token account
     price_sol: float | None
     attempts: int
+    deposit_lamports: int = 0         # SOL the swap put into the mint's token account (its rent, a first buy) or took back out (< 0)
 
 
 def _int_or_none(v) -> int | None:
@@ -339,6 +341,10 @@ class LiveBroker:
                     log.warning("fill %s: snapshot deltas (%d, %d) differ from the transaction's (%d, %d); using the transaction",
                                 signature[:12], lam, tok, exact[0], exact[1])
                 lam, tok = exact
+        # the rent a first buy pays to open the mint's token account (~0.0015 SOL) is a deposit the account's close returns,
+        # not the trade: the trade's SOL, its price and the position's cost leave it out (it is kept on the position)
+        dep = int(post.deposits.get(mint, 0)) - int(pre.deposits.get(mint, 0))
+        lam += dep
         # a confirmed sell that moved the tokens is a fill even at lam <= 0 (a rugged token's dust proceeds < fees)
         verified = (lam < 0 and tok > 0) if side == "buy" else (tok < 0 and (lam > 0 or chain_status == "confirmed"))
         jup_status = (ex or {}).get("status")
@@ -353,7 +359,7 @@ class LiveBroker:
                                         order.get("platformFee"), verified_by, pre, post)
             log.info("fill %s: %s %s token_delta=%d lamports_delta=%d price_sol=%s (%s)",
                      fill_id, side, mint, tok, lam, price, verified_by)
-            return FillResult(True, order_id, fill_id, signature, chain_status, code, error, tok, lam, price, attempt), False
+            return FillResult(True, order_id, fill_id, signature, chain_status, code, error, tok, lam, price, attempt, dep), False
         if jup_status == "Success" or chain_status == "confirmed":
             tx_info = None
             try:
@@ -506,6 +512,9 @@ def close_empty_atas(rpc=None, signer=None, url: str | None = None, batch: int =
             with transaction(url) as conn:
                 conn.execute("INSERT INTO wallet_events (kind, pubkey, detail) VALUES ('ata_closed', %s, %s)",
                              (owner_s, Jsonb(detail)))
+                if status == "confirmed":             # their rent is back in the wallet: no longer a deposit the books hold
+                    for m in sorted({a["mint"] for a in chunk}):
+                        ledger.refund_deposits(conn, "live", m)
         except Exception as e:
             log.warning("wallet_events insert failed: %s", type(e).__name__)
         if status == "confirmed":

fly_trader/execution/ledger.py

@@ -67,7 +67,9 @@ def _chain_of(book: str) -> str:
 
 def open_position(conn, *, book: str, mint: str, pool: str | None, qty_raw: int, cost_sol: float,
                   entry_price: float, decision_id: int | None, fees_sol: float, ts: datetime | None = None,
-                  hold_s: float | None = None, strategy: str | None = None) -> int:
+                  hold_s: float | None = None, strategy: str | None = None, deposit_sol: float = 0.0) -> int:
+    """``deposit_sol``: what the buy put into the mint's token account (its rent, a first live buy), kept apart from
+    ``cost_sol``: the account's close returns it (``refund_deposits``)."""
     ts = ts or datetime.now(timezone.utc)
     existing = conn.execute("SELECT id, qty, cost_sol, entry_price FROM positions WHERE book=%s AND mint=%s AND status='open'",
                             (book, mint)).fetchone()
@@ -75,18 +77,36 @@ def open_position(conn, *, book: str, mint: str, pool: str | None, qty_raw: int,
         q0, c0 = int(existing["qty"]), float(existing["cost_sol"])
         q1, c1 = q0 + qty_raw, c0 + cost_sol
         p1 = (float(existing["entry_price"] or entry_price) * q0 + entry_price * qty_raw) / max(q1, 1)
-        conn.execute("UPDATE positions SET qty=%s, cost_sol=%s, entry_price=%s, fees_sol=fees_sol+%s, last_mark_price=%s, last_mark_ts=%s WHERE id=%s",
-                     (q1, c1, p1, fees_sol, entry_price, ts, existing["id"]))
+        conn.execute("UPDATE positions SET qty=%s, cost_sol=%s, entry_price=%s, fees_sol=fees_sol+%s, last_mark_price=%s, last_mark_ts=%s, "
+                     "deposit_sol = NULLIF(COALESCE(deposit_sol, 0) + %s, 0) WHERE id=%s",
+                     (q1, c1, p1, fees_sol, entry_price, ts, deposit_sol, existing["id"]))
         return int(existing["id"])
     row = conn.execute(
         """INSERT INTO positions (book, mint, pool, opened_at, entry_decision_id, qty, cost_sol, entry_price, peak_price,
-             last_mark_price, last_mark_ts, fees_sol, status, last_swap_ts, hold_s, strategy, chain)
-           VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,'open',%s,%s,%s,%s) RETURNING id""",
-        (book, mint, pool, ts, decision_id, qty_raw, cost_sol, entry_price, entry_price, entry_price, ts, fees_sol, ts, hold_s, strategy, _chain_of(book)),
+             last_mark_price, last_mark_ts, fees_sol, status, last_swap_ts, hold_s, strategy, chain, deposit_sol)
+           VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,'open',%s,%s,%s,%s,%s) RETURNING id""",
+        (book, mint, pool, ts, decision_id, qty_raw, cost_sol, entry_price, entry_price, entry_price, ts, fees_sol, ts, hold_s, strategy, _chain_of(book),
+         deposit_sol or None),
     ).fetchone()
     return int(row["id"])
 
 
+def refund_deposits(conn, book: str, mint: str) -> float:
+    """The mint's token-account deposits not yet returned (paid by the buy that opened the account, whichever position
+    of the mint closes it), marked returned; their total in SOL. 0 when none was booked apart (a position bought before
+    deposits were: its cost holds the rent, so the whole refund is its own)."""
+    rows = conn.execute("UPDATE positions SET deposit_refunded = true WHERE book = %s AND mint = %s AND COALESCE(deposit_sol, 0) > 0 AND NOT deposit_refunded "
+                        "RETURNING deposit_sol", (book, mint)).fetchall()
+    return sum(float(r["deposit_sol"]) for r in rows)
+
+
+def deposits_held(conn, book: str) -> float:
+    """SOL the book's token accounts hold as deposits (their rent) until their close returns it: part of its wealth."""
+    r = conn.execute("SELECT COALESCE(sum(deposit_sol), 0) AS s FROM positions WHERE book = %s AND COALESCE(deposit_sol, 0) > 0 AND NOT deposit_refunded",
+                     (book,)).fetchone()
+    return float(r["s"])
+
+
 def realize_partial(conn, *, position_id: int, qty_raw: int, cost_part: float, proceeds_sol: float, fees_sol: float,
                     price: float, ts: datetime | None = None) -> float | None:
     """Shrink an open position by qty_raw / cost_part and book proceeds − cost_part into realized_sol.

fly_trader/execution/worker.py

@@ -163,10 +163,13 @@ class ExecutionWorker:
                     price = fr.price_sol or (cost / max(fr.token_delta / (10 ** req.decimals), 1e-12))
                     pid = ledger.open_position(conn, book="live", mint=req.mint, pool=req.pool, qty_raw=fr.token_delta,
                                                cost_sol=cost, entry_price=price, decision_id=req.decision_id,
-                                               fees_sol=0.0, ts=ts, hold_s=req.hold_s, strategy=req.strategy)
+                                               fees_sol=0.0, ts=ts, hold_s=req.hold_s, strategy=req.strategy,
+                                               deposit_sol=max(fr.deposit_lamports, 0) / config.LAMPORTS_PER_SOL)
                     rails.record_notional(conn, cost, "entry")
                     return ExecResult(req, True, fr.fill_id, fr.signature, fr.token_delta, fr.lamports_delta, price, position_id=pid)
                 else:
+                    if fr.deposit_lamports < 0:                # the swap closed the token account itself: its deposit is back
+                        ledger.refund_deposits(conn, "live", req.mint)
                     proceeds = fr.lamports_delta / config.LAMPORTS_PER_SOL
                     price = fr.price_sol if fr.price_sol is not None else (proceeds / max(abs(fr.token_delta) / (10 ** req.decimals), 1e-12))
                     if req.forced_kind == "dead_bag_sweep":    # a written-off position's tokens: what they fetch is that position's
@@ -208,11 +211,12 @@ class ExecutionWorker:
         return not req.retry and req.forced_kind != "dead_bag_sweep"
 
     def _close_account(self, req: ExecRequest, res: ExecResult) -> None:
-        """The sale left the live book without this mint: close its empty token account (the rent its first buy paid back
-        to the wallet: about a point of a 0.15 SOL round trip, read as execution loss by the gap monitor) and book what the
-        close returned, net of its fee, onto the position the sale closed. Not while a buy is queued behind the sale (it
-        needs the account) or the wallet still holds the token. A failure here never touches the sale: it is logged and
-        the account stays for ``close-empty-atas``."""
+        """The sale left the live book without this mint: close its empty token account. The rent its first buy paid comes
+        back to the wallet: the deposit booked apart on that buy's position is returned (``ledger.refund_deposits``) and only
+        the close's fee is the closing position's; a position bought before deposits were booked apart had the rent in its
+        cost, so the whole refund is its own. Not while a buy is queued behind the sale (it needs the account) or the
+        wallet still holds the token. A failure here never touches the sale: it is logged and the account stays (and its
+        deposit counts in wealth) for ``close-empty-atas``."""
         from ..vault import walletlock
         with self.lock:
             if self.inflight.get(req.mint) != ["sell"]:
@@ -224,8 +228,9 @@ class ExecutionWorker:
             with walletlock.maybe_exclusive(config.VAULT_ENABLED):
                 got = self.broker.close_token_account(req.mint)
             if got is not None and res.position_id is not None:
-                with transaction() as conn:
-                    ledger.credit(conn, res.position_id, got / config.LAMPORTS_PER_SOL)
-                res.realized_sol = (res.realized_sol or 0.0) + got / config.LAMPORTS_PER_SOL
+                with transaction() as conn:      # the account's deposit is back, less the close's fee: only the fee is the position's
+                    pnl = got / config.LAMPORTS_PER_SOL - ledger.refund_deposits(conn, "live", req.mint)
+                    ledger.credit(conn, res.position_id, pnl)
+                res.realized_sol = (res.realized_sol or 0.0) + pnl
         except Exception as e:
             log.warning("closing the token account of %s after its sale failed (the sale stands): %s: %s", req.mint, type(e).__name__, e)

fly_trader/kalshi/fly_replay.py

@@ -71,8 +71,9 @@ def _governance(ds, order, ts_o, res_o, upto, scores, lines, line_log, bank, now
         for c in range(1, lines.shape[0]):
             lc = R._line_at(line_log, (c, s_), ts_o[p3], float(lines[c, s_]))
             rp = gov.picks_returns(ds.ts[r3], ds.mint[r3], ds.hold_s[r3], np.nan_to_num(scores[c, s_, p3], nan=-np.inf), lc, y[r3])
-            s1 = scores[c, s_, p1]; has = np.isfinite(s1)
-            out = gov.check((rp[np.isfinite(rp)], rf[np.isfinite(rf)]), (s1[has], ds.outcome[r1][has]), drift[c])
+            s1 = scores[c, s_, p1]; f1 = scores[0, s_, p1]; has = np.isfinite(s1) & np.isfinite(f1)
+            out = gov.check((rp[np.isfinite(rp)], rf[np.isfinite(rf)]), (s1[has], ds.outcome[r1][has]), drift[c],
+                            ic_frozen_rows=(f1[has], ds.outcome[r1][has]))                  # as live: against the frozen shadow
             counts[(c, s_)]["checks"] += 1
             for t in out["triggers"]:
                 counts[(c, s_)][t] += 1

fly_trader/kalshi/fly_session.py

@@ -21,8 +21,8 @@ minute's live part, ``after_minute`` the rest, once the live orders are out.
    maker label the return of a bid one tick inside the ask when a later minute's ask reached it).
 
 Hourly: learning statistics (``kalshi_fly_updates``), a snapshot of the plastic state (kind 'kalshi_fly_plastic'), the
-rollback checks (train/fly_governance.py; a third rollback in 7 days freezes learning and asks kalshi/pipeline.py for a
-re-bootstrap). State: ``data/brain/plastic_kalshi/state.pt``; commands ``ui_settings['kalshi_fly_command']``; status
+rollback checks (train/fly_governance.py: they judge what learning did, against the frozen shadow; a third rollback of a
+strategy in 7 days freezes that strategy's learning and asks kalshi/pipeline.py for a re-bootstrap). State: ``data/brain/plastic_kalshi/state.pt``; commands ``ui_settings['kalshi_fly_command']``; status
 ``ui_settings['kalshi_fly_status']``; activity for the 3D view in ``data/brain/activity_kalshi/``.
 """
 from __future__ import annotations
@@ -141,6 +141,7 @@ class KalshiFlyBook:
         self.lines = {"plastic": dict(self.fly.lines), "frozen": dict(self.fly.lines)}
         self.sizing = {"plastic": {k: list(v) for k, v in self.fly.sizings.items()}, "frozen": {k: list(v) for k, v in self.fly.sizings.items()}}
         self.applied_through = -math.inf; self.learning_frozen = False; self.checks_paused_until = {k: 0.0 for k in self.names}
+        self.frozen: list[str] = []          # strategies whose learning the rollback limit froze (learning_frozen: the operator's pause, all)
         self.last_day: int | None = None; self.last_hour: int | None = None
         self.rollbacks: dict = {k: [] for k in self.names}; self.nu_set = False; self.hour_stats = self._empty_stats(); self.last_checks: dict = {}
         s = self._read_state()
@@ -148,6 +149,7 @@ class KalshiFlyBook:
             self.bank.load_state(s["bank"]); self.nu_set = True
             self.lines, self.sizing = s["lines"], s["sizing"]
             self.applied_through, self.learning_frozen, self.checks_paused_until = s["applied_through"], s["learning_frozen"], s["checks_paused_until"]
+            self.frozen = [k for k in s.get("frozen") or [] if k in self.names]
             self.last_day, self.last_hour, self.rollbacks = s["last_day"], s["last_hour"], s["rollbacks"]
         elif s:
             with transaction() as conn:
@@ -164,7 +166,8 @@ class KalshiFlyBook:
 
     def _state(self) -> dict:
         return {"bootstrap_id": self.boot_id, "cfg": self.cfg, "bank": self.bank.state(), "lines": self.lines, "sizing": self.sizing, "applied_through": self.applied_through,
-                "learning_frozen": self.learning_frozen, "checks_paused_until": self.checks_paused_until, "last_day": self.last_day, "last_hour": self.last_hour,
+                "learning_frozen": self.learning_frozen, "frozen": self.frozen, "checks_paused_until": self.checks_paused_until, "last_day": self.last_day,
+                "last_hour": self.last_hour,
                 "rollbacks": self.rollbacks, "saved_at": time.time()}
 
     def _write_state(self) -> None:
@@ -267,7 +270,7 @@ class KalshiFlyBook:
             self.last_day = day; self._calibrate(conn, ctx.m1_epoch)
         drift = {k: float(self.bank.drift(j)[0]) if self.bank.learn.shape[0] > 1 else float(self.bank.drift()[0]) for j, k in enumerate(self.names)}
         out.update({"lines": self.lines["plastic"], "frozen_lines": self.lines["frozen"], "arms": self.arms, "drift": max(drift.values()) if drift else 0.0,
-                    "drift_by_strategy": drift, "pending": len(self.pending), "learned": learned, "learning_frozen": self.learning_frozen, "channels": self.cfg,
+                    "drift_by_strategy": drift, "pending": len(self.pending), "learned": learned, "learning_frozen": self.learning_frozen, "frozen_strategies": self.frozen, "channels": self.cfg,
                     "bootstrap": self.boot_id, "device": str(self.fly.net.dev)})
         hour = int(ctx.m1_epoch // 3600)
         if self.last_hour is None:
@@ -386,12 +389,13 @@ class KalshiFlyBook:
                 self.pending.push(ss.keys, ss.ts, now + REARM_S, ss.y_dn, ss.u0, ss.k, ss.w, s=j)
             rearmed = [(datetime.fromtimestamp(now + REARM_S, timezone.utc), datetime.fromtimestamp(t, timezone.utc), tk, side, name) for t, tk, side, name in sub.keys]
         stats = {"n": int(keep.sum()), "unknown": int(sum(1 for k in out_keys if k[1] == "unknown")), "rearmed": rearmed, "keys": out_keys, "waiting": len(rearm)}
+        held = [self.names.index(k) for k in self.frozen if k in self.names]
+        learn = keep & ~np.isin(np.asarray(tags.s), held) if held else keep    # a strategy the rollback limit froze learns nothing
         if keep.any():
-            tv = tags.subset(keep)
-            if self.learning_frozen:
+            if self.learning_frozen or not learn.any():
                 self.bank.decay_to(now)
             else:
-                st = self.bank.update(tv, torch.tensor(labels[keep], dtype=torch.float32), now)
+                st = self.bank.update(tags.subset(learn), torch.tensor(labels[learn], dtype=torch.float32), now)
                 stats.update(mean_delta=st["mean_delta"][0], mean_abs_delta=st["mean_abs_delta"][0], step=st["step"][0], capped=bool(st["capped"][0]))
                 h = self.hour_stats; h["n"] += stats["n"]; h["sum_delta"] += st["mean_delta"][0] * stats["n"]; h["sum_abs"] += st["mean_abs_delta"][0] * stats["n"]
                 h["step"] += st["step"][0]; h["capped"] += int(st["capped"][0])
@@ -512,7 +516,7 @@ class KalshiFlyBook:
                 g = lambda c: np.array([r[c] for r in rows], dtype=np.float64)
                 rp = gov.picks_returns(ts, mint, hold, g("score"), g("line"), lab); rf = gov.picks_returns(ts, mint, hold, g("frozen_score"), g("frozen_line"), lab)
                 recent = np.array([r["resolved_at"].timestamp() for r in rows]) > now - gov.IC_HOURS * 3600.0
-                out[name] = gov.check((rp, rf), (g("score")[recent], lab[recent]), self._drift(j))
+                out[name] = gov.check((rp, rf), (g("score")[recent], lab[recent]), self._drift(j), ic_frozen_rows=(g("frozen_score")[recent], lab[recent]))
             else:
                 out[name] = gov.check(None, None, self._drift(j))
         return out
@@ -528,7 +532,7 @@ class KalshiFlyBook:
         good = not any(c["triggers"] for c in checks.values())
         sid = self._snapshot(conn, now, good, checks)
         for name, c in checks.items():
-            if c["triggers"] and now >= self.checks_paused_until.get(name, 0.0) and not self.learning_frozen:
+            if c["triggers"] and now >= self.checks_paused_until.get(name, 0.0) and not self.learning_frozen and name not in self.frozen:
                 self._rollback(conn, now, c, sid, name=name)
         self._prune(conn, now)
         activity.prune(kalshi_activity_dir(), now - activity.KEEP_S)
@@ -558,7 +562,7 @@ class KalshiFlyBook:
         if cmd == "pause":
             self.learning_frozen = True; record_event("info", NAME, "learning paused by the operator")
         elif cmd == "resume":
-            self.learning_frozen = False; self.rollbacks = {}; record_event("info", NAME, "learning resumed by the operator")
+            self.learning_frozen = False; self.frozen = []; self.rollbacks = {}; record_event("info", NAME, "learning resumed by the operator")
         elif cmd == "rollback":
             for j, name in enumerate(self.names):
                 self._rollback(conn, now, {"triggers": ["operator"], "drift": self._drift(j)}, None, count=False, name=name)
@@ -585,10 +589,11 @@ class KalshiFlyBook:
                      (f"{name}: " + ", ".join(checks["triggers"]), json.dumps(checks, default=str), from_sid, target["id"] if target is not None else None))
         record_event("warning", NAME, f"{name} channel rolled back ({', '.join(checks['triggers'])})", {"to_snapshot": target["id"] if target is not None else "bootstrap (D = 0)", "checks": checks})
         if count and len(self.rollbacks[name]) >= ROLLBACK_LIMIT:
-            self.learning_frozen = True
+            self.frozen = sorted(set(self.frozen) | {name})       # this strategy's learning only: the others keep learning
             from . import pipeline
             pipeline.request_run(fly=True, reason=f"{name}: {len(self.rollbacks[name])} rollbacks in 7 days")
-            record_event("error", NAME, f"learning frozen after {len(self.rollbacks[name])} {name} rollbacks in 7 days; re-bootstrap requested", {"rollbacks": self.rollbacks})
+            record_event("error", NAME, f"{name} learning frozen after {len(self.rollbacks[name])} rollbacks in 7 days; re-bootstrap requested",
+                         {"rollbacks": self.rollbacks, "frozen": self.frozen})
 
     def _prune(self, conn, now: float) -> None:
         rows = conn.execute("SELECT id, path, ts FROM brain_snapshots WHERE kind = %s AND ts < %s ORDER BY ts DESC",

fly_trader/train/fly_governance.py

@@ -1,11 +1,16 @@
 """The checks that roll the fly's plasticity back (live, hourly) — and are counted in the replay to measure false alarms.
 
-Any one trips a rollback:
+They judge what learning did, so a channel that has learned nothing (drift at most ``DRIFT_MIN``: a learning rate of 0,
+or a memory decayed back to its bootstrap) trips none: there is nothing for a rollback to undo. Otherwise any one trips
+a rollback:
 - shadow: over the last ``SHADOW_DAYS`` days of resolved picks (each arm at its own line, one position per token), the
   plastic fly's mean net return per trade is more than one standard error below its frozen shadow's (the bootstrap fly,
   D = 0, scoring the same minutes), with at least ``SHADOW_MIN_TRADES`` trades on each side;
-- ic: the rank correlation of its scores with the realized returns over the last ``IC_HOURS`` hours is below 0
-  (at least ``IC_MIN_ROWS`` resolved minutes);
+- ic: over the last ``IC_HOURS`` hours (at least ``IC_MIN_ROWS`` resolved minutes), the rank correlation of its scores
+  with the realized returns trails its frozen shadow's on the same rows by more than ``IC_MARGIN`` -- learning ranked
+  worse than its bootstrap. Not merely below 0: a fly that scores as its teacher would then be rolled back for the
+  teacher's own bad day (2026-10-11..13: ev, learning rate 0, rolled back three times at IC -0.10..-0.13, which froze
+  learning). Without the shadow's rows, below 0;
 - drift: ‖D‖_F / ‖w0‖_F above ``DRIFT_MAX``.
 """
 from __future__ import annotations
@@ -17,6 +22,8 @@ from .decisions import rank_corr, taken_idx
 SHADOW_DAYS, SHADOW_MIN_TRADES = 3, 30
 IC_HOURS, IC_MIN_ROWS, IC_SAMPLE = 24, 5000, 50_000
 DRIFT_MAX = 0.5
+DRIFT_MIN = 1e-3             # at most this far from its bootstrap, a channel has learned nothing a rollback could undo
+IC_MARGIN = 0.02             # how far the plastic fly's IC must trail its frozen shadow's to count as learning's harm
 
 
 def shadow_check(r_plastic: np.ndarray, r_frozen: np.ndarray, min_trades: int = SHADOW_MIN_TRADES) -> tuple[bool, dict]:
@@ -50,8 +57,11 @@ def picks_returns(ts: np.ndarray, mint: np.ndarray, horizon_s: float, scores: np
     return np.asarray(rets)[taken_idx(ts, mint, horizon_s, idx)]
 
 
-def check(shadow: tuple[np.ndarray, np.ndarray] | None, ic_rows: tuple[np.ndarray, np.ndarray] | None, drift: float) -> dict:
-    """All three checks; ``triggers`` lists the ones that tripped."""
+def check(shadow: tuple[np.ndarray, np.ndarray] | None, ic_rows: tuple[np.ndarray, np.ndarray] | None, drift: float,
+          ic_frozen_rows: tuple[np.ndarray, np.ndarray] | None = None) -> dict:
+    """All three checks; ``triggers`` lists the ones that tripped. ``ic_frozen_rows``: the frozen shadow's scores and the
+    labels of the same rows as ``ic_rows``. A channel at or below ``DRIFT_MIN`` trips nothing (what would have tripped is
+    ``not_counted``)."""
     out = {"triggers": [], "drift": float(drift)}
     if shadow is not None:
         t, d = shadow_check(*shadow); out["shadow"] = d
@@ -59,8 +69,13 @@ def check(shadow: tuple[np.ndarray, np.ndarray] | None, ic_rows: tuple[np.ndarra
             out["triggers"].append("shadow")
     if ic_rows is not None:
         t, ic = ic_check(*ic_rows); out["ic"] = ic
+        if ic_frozen_rows is not None:
+            _, icf = ic_check(*ic_frozen_rows); out["ic_frozen"] = icf
+            t = ic is not None and icf is not None and ic < icf - IC_MARGIN
         if t:
             out["triggers"].append("ic")
     if drift_check(drift):
         out["triggers"].append("drift")
+    if float(drift) <= DRIFT_MIN and out["triggers"]:
+        out["not_counted"], out["triggers"] = out["triggers"], []
     return out

fly_trader/train/fly_replay.py

@@ -324,10 +324,10 @@ def _governance(ds, order, ts_o, scores, lines, line_log, bank, now, lags, holds
                 sc3 = np.where(other3, np.nan, sc3)
             sc3 = np.nan_to_num(sc3, nan=-np.inf)
             rp = gov.picks_returns(ds.ts[r3], ds.mint[r3], H * 60.0, sc3, lc, y[r3])
-            s1 = scores[c, s_, a1:b1]; has = np.isfinite(s1)
+            s1 = scores[c, s_, a1:b1]; f1 = scores[0, s_, a1:b1]; has = np.isfinite(s1) & np.isfinite(f1)
             if ci is not None:
                 has = has & (slots.cidx_o[a1:b1] == ci)
-            out = gov.check((rp, rf), (s1[has], y[r1][has]), drift[c])
+            out = gov.check((rp, rf), (s1[has], y[r1][has]), drift[c], ic_frozen_rows=(f1[has], y[r1][has]))   # as live: against the frozen shadow
             counts[(c, s_)]["checks"] += 1
             for t in out["triggers"]:
                 counts[(c, s_)][t] += 1