release 10 (7e2ff90c0e)

CHANGELOG.md

@@ -3,6 +3,238 @@
 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-23, release 10: A retrained selector trades `ev` again, and live money follows the seat
+
+Published to Hugging Face as signed release 10. It ships selector #560 and fly #561 in place of selector #154 and fly
+#157:
+
+- **Selector #560** is fitted through 2026-10-20 on this release's rules and trades `ev` again besides `capitulation`. On
+  the 18 days 2026-10-03..10-20, out of sample for both, its holdout-blind copy made +9.71 % per trade over 393 trades
+  (62 % winners, profit factor 2.08); #154 made +9.64 % over 392 (58 %, 1.95).
+- **Fly #561** is taught by it. Its own decisions reach the wallet only once it wins its 14-day race (Live money below).
+
+### 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 10`.
+- **The corpus is rebuilt once on start,** because the Solana universe changed: about 5 hours in a child process at the
+  lowest CPU priority. The rebuild retires no model.
+- **New tables and columns are added on start:** `corpus_meta.grad_quote`; on Robinhood Chain, `rh_v4_keys`,
+  `rh_v4_tokens` and new `rh_pools` and `rh_meta` columns.
+- **Robinhood Chain installs:** run `fly-trader rh-v4-backfill` once, under `nice -n 19` and apart from the console, so
+  v4 pools older than the console's watch are found.
+- **New settings:** `EXEC_THREADS` (default 4), `SOL_FEED` (default `pumpapi`), `STREAM_RELAY_URL`, `STREAM_RELAY_TOKEN`,
+  `STREAM_RELAY_CA_FILE`, `HELIUS_FEED_COMMITMENT`, `REFETCH_PARALLEL`, `REFETCH_MAX_LAG_S` and `REFETCH_SKIP_RECENT_H`.
+- **On an install whose fly already won its race, fly #561 inherits that seat** and trades live without racing first.
+  The next release makes every new fly race.
+
+### Live money
+
+- **Minutes are processed 2–3× faster: a minute is ready a median 2.8 s after its end, down from 6.4 s.** Measured with
+  `tools/latency_probe.py` against the 2026-10-19 baseline. Figures are seconds after the minute ends:
+
+  | | Old median | New median | Old p90 | New p90 | Old max | New max |
+  |---|---|---|---|---|---|---|
+  | Stream publishes the minute | 4.3 | 2.3 | 16.3 | 9.9 | 17.6 | 41.9 |
+  | Selector done (the console's "latency") | 6.4 | 2.8 | 16.9 | 10.3 | 18.4 | 42.5 |
+  | Publish → selector done | 0.7 | 0.5 | 1.1 | 1.0 | 4.3 | 3.7 |
+
+  - The worst minute waited 41.9 s for PumpAPI's stream to publish it. The feed is now the remaining delay, not the
+    engine (see Platform).
+  - The fly's status records each minute's timing: when its rows were ready, when the fly decided and when the live
+    orders were queued (`seen_s`, `scored_s`, `orders_s`). The first minutes after the change: Solana 2.42, 2.47 and
+    2.48 s; Robinhood Chain 4.79, 4.84 and 4.85 s. That is about 50 ms from a minute's data to its live orders.
+- **The fly decides a live minute on one pass of its teacher.**
+  - It takes the selector's decision once and scores only the rows the selector would buy, the input of its learned veto.
+  - Every other row's score, its learning tag and the brain view wait until after the live orders.
+  - Live scoring takes about 6 ms, down from a median 94 ms (150–400 ms when the GPU was idle), with the same decisions
+    on 40 real minutes.
+- **Solana swaps run in parallel.**
+  - Up to four swaps are in flight at once (`EXEC_THREADS`): one per token, and each token's in order.
+  - Each fill is read from its own transaction, since another swap may land between a swap's two balance reads.
+  - If a transaction cannot be read while other swaps are in flight, the fill is recorded as unknown and entries pause
+    until `verify-fills` reconciles it.
+  - Robinhood Chain swaps stay one at a time.
+- **Nothing in front of a live order waits that need not.**
+  - The wallet's balance is read while the minute is scored.
+  - The balances before a swap are read beside Jupiter's quote and the signing, in one round trip.
+  - The signer's lookups run side by side, and a swap's confirmation is checked every slot instead of every second.
+- **The engine wakes the moment a minute is written,** instead of looking every 250 ms.
+  - The stream checks for complete minutes every 50 ms, on its own clock.
+  - Both chains run their live phases and send their boundary sales at the same time.
+  - Paper work steps aside when another chain's minute lands meanwhile.
+- **A failed live entry is tried again only while the fly would still buy the token, at that minute's price.**
+  - Before, every retry was checked against its decision's price. Once a token ran more than 3% (`MAX_ENTRY_CHASE`),
+    every retry was refused as "price ran" until the two retry minutes were up: a runner missed once was missed for good.
+  - Each minute's plan now says, for every token paper holds, whether it would buy it again and what paper would pay at
+    that minute's price. A retry goes out on that minute's score and against that price, or waits, recorded as
+    "no longer a buy" with the score against its line. Both chains.
+- **Sell now: any open live position can be sold from the Overview's open positions, on both chains.**
+  - After a confirmation, the wallet sells the whole position at once, at the exit's slippage of 3% stepping up to at most
+    5%, and books it like any exit. The console waits up to 90 s and says what the sale brought, or why it failed.
+  - The fly's paper book keeps its own position. An operator's sale counts neither in the live-vs-paper gap that pauses
+    entries nor in what the fly learns about its fills.
+- **Live money follows the seat: until the fly wins its race, the wallet trades the selector's decisions.**
+  - Before, with `LIVE_WITHOUT_HANDOVER` on, the wallet traded the fly's decisions whoever held the seat. Those are the
+    selector's picks less what the fly's learning vetoes, so an untested fly's learning reached live money before its race.
+  - Now, until the handover, a pick the fly's learning vetoes still goes live as the selector decided it. It stays out of
+    the fly's paper book, which is what the race compares with the selector's. Once the fly holds the seat, its vetoes
+    bind the wallet too. A pick the selector itself blocks never goes live. Both chains.
+- **A Robinhood Chain minute is written in milliseconds at any hour, not up to 2.5 s late in the UTC day.**
+  - Writing each minute re-read every swap since 00:00 UTC to warm the price filter (the median of a coin's previous 200
+    prices that day): about 130,000 swaps and 2.1–2.5 s by 23:59, in front of that minute's live entries.
+  - It now reads only each coin's last 200 prices that day: 0.03–0.07 s at 23:59. On 18 real ranges (single minutes at
+    23:59, noon and now, 240 minutes, across midnight, a whole day, and four quote assets) the rows are identical.
+- **The Robinhood Chain corpus is built in a child process, never in the stream's thread.**
+  - At 00:00 UTC the stream built the previous day's training files itself: about 30 s on 2026-10-23, after that minute's
+    write and before the next one's. The other v4 pools (The universe) add several times the swaps.
+  - The stream now only looks at the files and starts `fly-trader rh-build-corpus` at the lowest CPU priority, one at a
+    time.
+- **Two reads the latency probe caught after the 2026-10-23 restart are cheap now, and off the live path.**
+  - The Solana stream reloads the blocked custom pools every 5 minutes on the loop that flushes its minutes. Since the
+    suffix-less graduates, that read probed `corpus_meta` once per pool row: up to 3.5 s. It now joins the two tables
+    (the same 32,308 pools, 1.9 s → 65 ms on a copy) and runs on a thread.
+  - `build-mature` read the same pools for every day of a rebuild; it now reads them once per round.
+  - The Robinhood Chain corpus read every coin's median fee over all of `rh_minutes` (13 s) for every day it built. It now
+    reads them once per run, in the middle of a minute, and a run builds up to 31 days.
+
+### The universe
+
+- **Solana: pump.fun graduates whose mint does not end in "pump" are traded too.**
+  - They are 4–22 % of a day's graduations (40–60 a day this week), with the same launchpad, creator history, burned pool
+    liquidity and token rules as the rest. A mint-suffix test dropped them in the stream, the corpus and the wallet skill.
+  - A coin now counts as pump.fun's when its mint ends in "pump" or a pump.fun migration recorded it: the stream adds a
+    graduate the moment it sees the migration and reloads `corpus_meta`'s every 5 minutes. Their custom pools stay blocked.
+  - On 2026-10-21 they add 1,582 mints to the day's 10,754 and 5.5 % of its volume. No existing row changes.
+  - The corpus is rebuilt to include them (aggregation version 5). The current selector and fly keep trading through it.
+- **Solana: a pump.fun coin's Meteora DLMM pools make its minutes too.**
+  - Each minute keeps the pool with the most legs, as before, now among the coin's SOL-quoted PumpSwap and DLMM pools.
+    The stream and the corpus apply the same rule: on 2026-10-22 15:00 UTC both gave 24,552 minute rows for 3,078 coins.
+  - In that hour 99 % of minutes kept their pool, 210 minutes of 39 coins moved to a DLMM pool, and 101 coins gained 937
+    minutes. Coins graduated into a pool quoted in TTWO, PUMP, WBTC or USDC (Dacity, Macca, pill, baton, Au) have their
+    only SOL market there.
+  - A graduation's quote asset is now kept (`corpus_meta.grad_quote`): from the migration, or for an older coin from trades
+    in its own pool. A coin graduated in another quote has its dev buy and seed reserve in that quote's units, so those two
+    inputs read as unknown for it, live and in training. 17 % of graduations on 2026-10-20 were not in SOL.
+  - Paper fills charge the minute's pool fee, so a DLMM minute costs that pool's dynamic fee.
+- **Robinhood Chain: a Pons coin's own Uniswap v4 pools elsewhere, and plain v4 memecoins, are traded too.**
+  - The stream already read every PoolManager log and kept only the Pons pools'. In one hour on 2026-10-23, 1,480 v4
+    pools traded 40,960 times; the Pons pools made 3,375 of those swaps. 85 hookless pools pairing a coin with ETH, WETH or
+    USDG cleared the bot's floors, with 17,051 swaps.
+  - A pool is looked at once it trades: its last half hour must clear the RH book's floors (reserve and 15-minute
+    volume, in ETH). Of 1.07 million v4 pools on the chain, only those few hundred a day are registered.
+  - A new pool qualifies when it pairs a coin with ETH, WETH or USDG (`RH_V4_QUOTES`) and has no hook. A graduated Pons
+    coin's other pool may use any priced quote.
+  - Hooked pools stay out unless named in `RH_V4_HOOKS`. In a hookless pool the Swap event's amounts equal the
+    PoolManager's token flows exactly (230 swaps measured). The dynamic-fee hook of ORBIO's and ZZZ's other USDG pools
+    (`0x08e5…a080`) moved up to 6 times more than its Swap events show. The Pons coins' main outside pools are hookless,
+    with fees of 0.8–3 %.
+  - A plain coin's contract is checked first, busiest coins first, one a minute (`RH_V4_CHECKS_PER_SLOT`). It is refused
+    when its owner or an admin role can mint, upgrade, blacklist, pause, set taxes or hooks, or switch trading; when it
+    has a built-in tax; when it is not 18 decimals; and when it is a major, stablecoin or tokenized stock. On 15 known
+    coins the check matched a manual review.
+  - Its creator is the sender of its first pool's initialization, with the same history inputs as a Pons deployer. Its
+    age counts from that pool. What only a Pons launch records reads as unknown.
+  - Nothing of this runs in front of a minute: the stream keeps the pass's logs after the minute is written, and the rest
+    runs mid-minute once that minute is written and no live order waits on either chain. Only the contract checks read
+    the network: the public RPC, once per read, never after 40 s into the minute.
+  - A pool goes live with its coin's meta in one commit, between two passes, so the stream indexes every swap from the
+    next block on. A plain coin trades only after the engine has watched it for 3 hours, the longest feature window.
+  - `fly-trader rh-v4-backfill` (its own process) imports every pool's key since block 0, so pools older than the
+    console's watch can be found. It then backfills each live pool's history before it went live.
+  - A coin with several live pools takes each minute from the one with the most swaps, as on Solana. A non-Pons pool's
+    swaps carry its LP fee. WETH counts as ETH.
+
+### The selector
+
+- **A strategy's win filter chooses only its cut-off, at the strategy's own line, and must beat having no filter.**
+  - Before, the filter searched the line too. In selector #154 it moved `ev`'s line from 0.038 to 0.115, which `ev`'s live
+    scores never reached, so `ev` stayed deployed but never traded.
+- **The book keeps the passed strategies, and the combination rule, that together do best on the selection half.**
+  - Every subset of the strategies that passed is scored as one book under each rule. A strategy the book does better
+    without is dropped in the open, as its own "combination" row with the numbers.
+  - The combination step no longer says a rule "made more" when no book cleared the bars.
+
+### Training
+
+- **A corpus rebuild never retires a model.**
+  - The corpus build versions (`mature.AGG_VERSION`, `rh/corpus.RH_AGG_VERSION`) say when the corpus files are rebuilt,
+    not what a model's inputs, labels or costs mean. They are no longer part of a model's definitions.
+  - Before, raising one retired every selector and fly and stopped all trading until a retrain and replay, even for data
+    already in the corpus. Models, flies and replay verdicts that still carry the old keys stay current.
+  - A changed or missing definition still retires a model, as before.
+- **A rebuild of more than three days runs in a child process at the lowest CPU priority.**
+  - Re-featuring the whole archive takes about 5 hours (~100 s a day). It no longer shares the console's interpreter with
+    the live minute pipeline. A day's routine build stays in the console, as before.
+- **The wallet skill counts SOL-quoted legs only.** A leg quoted in another token counted its amount as SOL.
+- **The fly's training writes a checkpoint after every epoch, and resumes from it.**
+  - Before, a bootstrap (10–20 hours) kept its progress in memory only. A crash or a stop lost every finished epoch,
+    and training could not go on past its epoch cap.
+  - Now each epoch saves the weights, the optimiser, the history, the best epoch so far and the random state. A stopped
+    or crashed bootstrap resumes after its last finished epoch, and a finished one can train on past the cap it ran under.
+  - A checkpoint written for other training data is set aside, never resumed. The live bootstrap deletes its checkpoint
+    once the fly is saved.
+- **A new fly may race once its calibration week made money over 30 trades, the race's own minimum (was 100).**
+  - The wallet trades the selector's decisions until the fly wins its race, so the calibration week need not prove more
+    than the race will. A quiet week (2026-10-15..21) gave the new fly 88 trades at +2.96%, which the old bar refused.
+  - A losing calibration week still never deploys a fly. The Kalshi fly keeps 100.
+
+### The console
+
+- **The fly decision inspector shows the token's price and volume in the minute the fly last scored it.** Each has a
+  green or red arrow for its move over the five minutes before: the price against the close five minutes earlier, the
+  volume against the five minutes' average. Both are plain decimals, never scientific notation.
+- **The Overview's open positions table fits its card without scrolling sideways, from 1200 px wide up.**
+  - The card takes seven twelfths of the row and the wealth chart five, the other way round from before. The chart
+    still shows its whole history.
+  - The table's headers wrap onto two lines, its cells pad less, and a long token name ends in an ellipsis.
+
+### Platform
+
+- **The archive's hour files keep every venue's SOL-quoted trades, not only pump.fun's curve and PumpSwap.**
+  - Meteora DLMM and DAMM, Raydium, Orca and other launchpads' curves add about a third to the rows (~90 MB an hour).
+    The lifecycle events keep the quote mint. Both files are written atomically and the trades file says what it keeps.
+  - `fly-trader refetch-archive` downloads the older hours again in its own process, 2 at a time (`REFETCH_PARALLEL`).
+    It starts no download while the live stream is more than 15 s behind (`REFETCH_MAX_LAG_S`), leaves the newest 6 hours
+    to the console, and rebuilds each finished day itself. About 4,500 hours, roughly 2.7 TB of downloads; run it under
+    `nice -n 19` only after the console runs this code. Progress: `ui_settings['replay_refetch_status']`.
+  - A day is rebuilt whenever one of its hour files is newer than its aggregate.
+- **The stream relay forwards pump.fun graduates without the "pump" suffix and every SOL-quoted DLMM trade.**
+- **A stream relay is ready, but switched off.**
+  - `stream_relay/` holds PumpAPI's stream on a server near its source. It forwards only the events and fields the
+    minutes use: about 33 KB/s at the busiest minute, instead of the whole stream.
+  - It serves them over TLS with a token, and resumes without loss after a dropped connection.
+  - With `SOL_FEED=relay` it becomes the minutes' clock, and this machine's own PumpAPI connection stays as its backup.
+  - Setup is in `stream_relay/README.md`. `fly-trader relay-check` tests a relay without switching anything.
+  - New settings: `SOL_FEED` (default `pumpapi`), `STREAM_RELAY_URL`, `STREAM_RELAY_TOKEN` and `STREAM_RELAY_CA_FILE`.
+- **A Helius decoder is built, but switched off** (`SOL_FEED=helius`).
+  - It turns pump.fun and PumpSwap transactions into PumpAPI's events exactly as the archive has them: 312 of 312 events
+    per sampled slot, and trades, creates and migrations field for field.
+  - Helius's websockets deliver only about 1 MB/s in all to this machine, and drop trades when the market is busy.
+
+### Tools
+
+- **`tools/make_seed.py` judges the stored replay verdict as the fly session and `apply-release` do,** with the corpus
+  build versions set aside (`selector.defs_match`). It compared the verdict's definitions exactly, so the corpus rebuild
+  that retires no model still blocked a release.
+- **`tools/latency_probe.py` and `tools/latency_report.py` measure the minute pipeline from outside the console.**
+  - They sample, four times a second, when the stream publishes each minute, what SQL the console is running, when each
+    book's status lands, the console's CPU and every live order. The report turns that into per-minute timelines.
+  - They're read-only and need no restart. Run them before and after a change to the minute pipeline.
+  - The 2026-10-19 baseline of the old code is in `logs/latency_baseline_20261019/`. A minute was ready a median 6.4 s
+    after its end (p90 16.9 s). Almost all of that was the wait for the stream to publish the minute; everything after
+    publishing took 0.7 s.
+- **`tools/strategy_study/` re-checks the trading strategy against fresh data without saving a model.**
+  - It runs the trainer's own capitulation fit and judges it on the trainer's selection half, evaluation half and holdout.
+  - Then it compares the live selector's decisions on days after its training, sells the same trades after every hold
+    from 10 to 480 minutes, and tests floors on liquidity, volume, activity, age and wash share.
+  - It is safe to run beside live trading. The dataset is built in a separate process and read from disk, and a guard
+    stops the run if the live console's minutes slow down or its memory is squeezed.
+  - The 2026-10-19 run kept selector #154's strategy and 240-minute hold. #154 made +8.6% per Solana trade on the 16 days
+    after its training, against +8.9% in its backtest. Holds from 180 to 480 minutes did about equally well, and no
+    floor beat the noise.
+
 ## 2026-10-18, release 9: The Overview page charts each chain's setups, and the money's book comes first
 
 Published to Hugging Face as signed release 9. Fly #157 and selector #154 are unchanged, and so are the definitions they

console/src/components/DataTable.tsx

@@ -32,9 +32,10 @@ function pages(cur: number, total: number): (number | '…')[] {
   return out
 }
 
-export function DataTable<R extends Record<string, unknown>>({ rows, cols, height = 560, filename = 'table', onRowClick, empty = 'No rows.', search = true, initialSort, pageSize }: {
+/** ``compact`` fits a narrow card: header labels wrap onto two lines and the cells pad less. */
+export function DataTable<R extends Record<string, unknown>>({ rows, cols, height = 560, filename = 'table', onRowClick, empty = 'No rows.', search = true, initialSort, pageSize, compact = false }: {
   rows: R[]; cols: Col<R>[]; height?: number; filename?: string; onRowClick?: (r: R) => void; empty?: ReactNode; search?: boolean
-  initialSort?: { key: string; desc?: boolean }; pageSize?: number
+  initialSort?: { key: string; desc?: boolean }; pageSize?: number; compact?: boolean
 }) {
   const fb = useFeedback()
   const [sort, setSort] = useState<{ key: string; desc: boolean } | null>(initialSort ? { key: initialSort.key, desc: !!initialSort.desc } : null)
@@ -97,7 +98,7 @@ export function DataTable<R extends Record<string, unknown>>({ rows, cols, heigh
         {search && <label className="dt-search">Search:<input className="form-control form-control-sm" value={filter} onChange={(e) => { setFilter(e.target.value); setPage(0) }} /></label>}
       </div>
       <div className="ftable-wrap" style={{ maxHeight: height }}>
-        <table className="ftable">
+        <table className={`ftable ${compact ? 'compact' : ''}`}>
           <thead>
             <tr>
               {cols.map((c) => (

console/src/fly/Inspector.tsx

@@ -9,7 +9,7 @@ import { useFeedback } from '../components/feedback'
 import { Callout, Caption, Card, Empty, Expander, Icon, KVList, Loaded, Md, Metric, Metrics, ProgressList, RowGroup, Segmented, Toggle, Widget, WidgetGrid,
   type WidgetColor } from '../components/ui'
 import { useStored, useTopic } from '../lib/hooks'
-import { ago, amount, dt, int, num, pct, shortAddr, tone, usd } from '../lib/format'
+import { ago, amount, dt, hm, int, num, pct, plain, shortAddr, tone, usd } from '../lib/format'
 
 type Scored = { ts: string; strategy: string; side?: string; score: number | null; frozen_score: number | null; line: number | null; label: number | null; state: string; teacher_allow?: boolean | null }
 type Latest = Scored & { hold_min?: number | null; frozen_line?: number | null; bootstrap_id?: number | null }
@@ -27,9 +27,10 @@ type Fill = { id: number; ts: string; book: string; side: string; amount: number
 type Pathway = { kc: number; mbon: number; delta: number; ratio: number; strategy: string; valence: string; kc_type: string | null; mbon_type: string | null }
 type Pathways = { mode: string; items: Pathway[]; note: string | null; changed: number; reference: string | null; bootstrap: number | null; running: boolean
   n_pairs?: number; drift: Record<string, number> }
+type Minute = { ts: string; price: number | null; volume: number | null; price_5m: number | null; volume_5m: number }
 type TokenData = {
   chain: string; chain_name: string; unit: string; mint: string; label: string; symbol: string | null; name: string | null; graduated_at: string | null; creator: string | null
-  explorer: string; books: { selector: string; fly: string; live: string }; fly_score: string; teacher_gate: boolean; learned_veto: number
+  explorer: string; books: { selector: string; fly: string; live: string }; minute?: Minute | null; fly_score: string; teacher_gate: boolean; learned_veto: number
   series: Scored[]; stats: Stat[]; total: Stat | null; latest: Latest[]; explain: string; decisions: Decision[]; positions: Position[]; fills: Fill[]
   pnl: { closed: number; realized: number; open: number; wins: number }; pathways: Pathways
 }
@@ -170,6 +171,23 @@ function DecisionTable({ rows, unit, kalshi }: { rows: Decision[]; unit: string;
   return <DataTable rows={rows} cols={cols} filename="inspector-decisions" empty={kalshi ? 'No decisions on the Kalshi books.' : "No decisions on this chain's books."} />
 }
 
+/** The token's price and volume in the newest scored minute, each with an up/down arrow against the five minutes before. */
+function MinuteWidgets({ m, unit, scored }: { m: Minute; unit: string; scored: boolean }) {
+  const dp = m.price !== null && m.price_5m ? m.price / m.price_5m - 1 : null
+  const dv = m.volume !== null && m.volume_5m > 0 ? m.volume / m.volume_5m - 1 : null
+  const which = scored ? 'the minute the fly last scored it' : 'its newest traded minute (the fly has not scored it)'
+  return (
+    <Metrics min={320}>
+      <Metric compact label={`Price · ${hm(m.ts)}`} value={m.price === null ? '—' : `${plain(m.price)} ${unit}`}
+        delta={dp === null ? 'no price five minutes before' : `${pct(dp, 1)} over 5 min`} tone={dp ? 'normal' : 'off'} icon="candlestick"
+        help={`The close of ${which}, ${dt(m.ts)} UTC, in ${unit} per token; the arrow is its change from the close five minutes earlier.`} />
+      <Metric compact label={`Volume · ${hm(m.ts)}`} value={m.volume === null ? '—' : `${plain(m.volume)} ${unit}`}
+        delta={dv !== null ? `${pct(dv, 0)} vs 5-min average` : m.volume ? 'up from none in the five minutes before' : 'no volume'} tone={dv || (dv === null && m.volume) ? 'normal' : 'off'}
+        icon="chart" help={`Buys plus sells in ${which}, ${dt(m.ts)} UTC; the arrow compares it with the mean volume of the five minutes before (a minute without trades counts as none).`} />
+    </Metrics>
+  )
+}
+
 /** What the fly would do with the newest scored minute, as colour widgets (states, not text). */
 function VerdictWidgets({ d }: { d: TokenData }) {
   const r = d.latest[0]
@@ -229,6 +247,7 @@ function TokenBody({ chain, mint, mode, setMode }: { chain: string; mint: string
                 <a className="btn btn-sm btn-light" href={d.explorer} target="_blank" rel="noreferrer"><Icon name="external" />{chain === 'sol' ? 'Solscan' : 'Explorer'}</a>
               </span>
             </div>
+            {d.minute && <><MinuteWidgets m={d.minute} unit={u} scored={d.latest.length > 0} /><div className="mt-3" /></>}
             <VerdictWidgets d={d} />
             <div className="mt-3" />
             <WidgetGrid min={320}>

console/src/lib/format.ts

@@ -50,6 +50,12 @@ export function sig(x: Num, digits = 4, signed = false): string {
   return (signed && v >= 0 ? '+' : '') + s
 }
 
+/** Significant digits as a plain decimal, never scientific notation: 3.079e-7 → "0.0000003079". */
+export function plain(x: Num, digits = 4): string {
+  const v = n(x)
+  return v === null ? '—' : v.toLocaleString('en-US', { maximumSignificantDigits: digits })
+}
+
 export function sci(x: Num, digits = 3): string {
   const v = n(x)
   return v === null ? '—' : v.toExponential(digits)

console/src/pages/Overview.tsx

@@ -6,6 +6,7 @@ import { BrainPanel } from '../brain'
 import { PageHead } from '../components/ChainPicker'
 import { BarChart, LineChart, RadialGauge, type Series } from '../components/Charts'
 import { DataTable, type Col } from '../components/DataTable'
+import { ActionButton } from '../components/feedback'
 import { HourWheel, hourColor, type HourBucket } from '../components/HourWheel'
 import { Callout, Caption, Card, Loaded, Md, Metric, Metrics, ProgressList, RowGroup, Segmented, Widget, WidgetGrid } from '../components/ui'
 import { useApp, type Market } from '../context'
@@ -54,8 +55,9 @@ type Minute = {
 }
 type RaceBook = { book: string; title: string; pnl: number | null; n: number; daily: number[] }
 type Race = { hidden: boolean; unit: string; handover?: boolean; success?: string | null; caption?: string | null; metrics?: RaceBook[]; series?: Series[]; days?: string[] }
-type Position = { mint: string; token: string; strategy: string; held_min: number; exits_in_min: number; cost: number; ret: number | null }
-type Book = { unit: string; history: [string, number][]; positions: Position[]; live?: boolean; book?: string; title?: string; sub?: string }
+type Position = { id: number; mint: string; token: string; strategy: string; held_min: number; exits_in_min: number; cost: number; ret: number | null }
+type Book = { unit: string; history: [string, number][]; positions: Position[]; live?: boolean; book?: string; title?: string; sub?: string; observer?: boolean
+  sell?: { from_pct: number; to_pct: number } }
 
 /** Python's %g: significant digits, trailing zeros dropped, an exponent outside 1e-4..1e±digits. */
 function g(x: number | null | undefined, digits = 6): string {
@@ -187,31 +189,45 @@ function RacePanel() {
   )
 }
 
-/** The selector book: its whole wealth history, and the open positions. */
+/** The money's book: its whole wealth history, and the open positions (a live one can be sold now, after a confirmation). */
 function BookPanel() {
-  const { chain } = useApp()
+  const { chain, market } = useApp()
   const b = useTopic<Book>('overview.book', { chain })
-  const cols = (u: string): Col<Position>[] => [
+  const sellCol = (d: Book): Col<Position> => ({
+    key: 'sell', label: '', value: () => '',
+    render: (r) => (
+      <ActionButton label="Sell now" icon="payments" name="overview.sell_now" body={{ chain, position_id: r.id }} variant="outline-danger" disabled={d.observer}
+        help={d.observer ? 'This console only observes: sell from the console that hosts the workers.' : undefined}
+        confirm={{
+          title: `Sell ${r.token} now?`, confirmLabel: 'Sell now', danger: true,
+          body: <>Sells all of it from the {market?.name ?? chain} wallet now, at market: slippage from {d.sell?.from_pct}% stepping up to at most {d.sell?.to_pct}%.
+            The result is booked on the live book. Cost {g(r.cost, 4)} {d.unit}{r.ret === null ? '' : `, ${pctPts(r.ret, 2, true)} gross at the last mark`}.
+            The fly's paper book keeps its own position. A sale cannot be undone.</>,
+        }} />
+    ),
+  })
+  const cols = (d: Book): Col<Position>[] => [
+    ...(d.live && d.sell ? [sellCol(d)] : []),
     { key: 'token', label: 'token', render: (r) => <TokenButton chain={chain} mint={r.mint} token={r.token} /> },
     { key: 'strategy', label: 'strategy' },
     { key: 'held_min', label: 'held (min)', num: true, render: (r) => num(r.held_min, 0) },
     { key: 'exits_in_min', label: 'exits in (min)', num: true, render: (r) => num(r.exits_in_min, 0) },
-    { key: 'cost', label: `cost (${u})`, num: true, render: (r) => g(r.cost, 4) },
+    { key: 'cost', label: `cost (${d.unit})`, num: true, render: (r) => g(r.cost, 4) },
     { key: 'ret', label: 'return (gross)', num: true, render: (r) => (r.ret === null ? null : <span className={`text-${tone(r.ret)}`}>{pctPts(r.ret, 2, true)}</span>) },
   ]
   return (
     <div className="row gx-4">
-      <div className="col-12 col-xl-7 d-flex">
+      <div className="col-12 col-xl-5 d-flex">
         <Card title={b.data?.title ?? 'Paper wealth'} icon="wealth" sub={b.data?.sub ?? 'the selector book since it started'} className="flex-fill">
           <Loaded state={b} height={260}>
             {(d) => d.history.length ? <LineChart series={[{ name: 'wealth', data: d.history }]} height={280} yFormat={(v) => `${v.toFixed(2)} ${d.unit}`} /> : <Caption>No marks yet.</Caption>}
           </Loaded>
         </Card>
       </div>
-      <div className="col-12 col-xl-5 d-flex">
+      <div className="col-12 col-xl-7 d-flex">
         <Card title="Open positions" icon="open" className="flex-fill">
           <Loaded state={b}>
-            {(d) => d.positions.length ? <DataTable rows={d.positions} cols={cols(d.unit)} pageSize={10} filename="open-positions" /> : <Caption>None open.</Caption>}
+            {(d) => d.positions.length ? <DataTable rows={d.positions} cols={cols(d)} pageSize={10} filename="open-positions" compact /> : <Caption>None open.</Caption>}
           </Loaded>
         </Card>
       </div>

console/src/theme/brand.css

@@ -267,6 +267,9 @@ pre.log { background: rgb(0 0 0 / 35%); border: 1px solid var(--fly-line); borde
 .ftable tbody tr.clickable { cursor: pointer; }
 .ftable th.num, .ftable td.num { text-align: right; font-variant-numeric: tabular-nums; }
 .ftable td.wrap { white-space: normal; min-width: 220px; }
+.ftable.compact thead th { white-space: normal; padding: 0.5rem 0.55rem; line-height: 1.3; vertical-align: bottom; }
+.ftable.compact td { padding: 0.45rem 0.55rem; }
+.ftable.compact td .link-btn { display: inline-block; max-width: 10rem; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; vertical-align: middle; }
 .ftable .pos { color: var(--fly-lime); }
 .ftable .neg { color: #ff8da1; }
 .dt-bottom { display: flex; align-items: center; gap: 0.75rem; flex-wrap: wrap; margin-top: 0.75rem; font-size: 13.5px; }

fly_trader/__main__.py

@@ -117,11 +117,37 @@ def _cmd_pumpstream(args):
     pumpstream.main()
 
 
+def _cmd_relay_check(args):
+    import json
+    from .ingest import relay_feed
+    print(json.dumps(relay_feed.check(args.seconds), indent=1))
+
+
 def _cmd_build_corpus_features(args):
     from .train import corpus_features
     corpus_features.main()
 
 
+def _cmd_rh_build_corpus(args):
+    from .logging_setup import setup
+    from .rh import corpus
+    setup("rh_corpus")
+    print(f"rh corpus: {corpus.run_locked(max_days=args.days)}")
+
+
+def _cmd_rh_v4_backfill(args):
+    from .rh import v4_universe
+    out = v4_universe.backfill_main(keys=not args.no_keys, history=not args.no_history)
+    print(f"rh v4 backfill: {out.get('keys', 0)} pool keys imported; history of {out.get('pools', 0)} live pools in {out.get('steps', 0)} steps; "
+          f"{out.get('outcomes', 0)} first-hour outcomes")
+
+
+def _cmd_refetch_archive(args):
+    from .ingest import replay_pull
+    out = replay_pull.refetch_main()
+    print(f"archive refetch: {out['done']} of {out['planned']} hours rewritten, {out['failed']} failed")
+
+
 def _cmd_refetch_pool_ids(args):
     from .ingest import replay_pull
     print(f"{replay_pull.refetch_missing_pool_id()} archive hours marked for re-download (run the replay worker or fly-trader replay-pull)")
@@ -329,10 +355,20 @@ def build_parser() -> argparse.ArgumentParser:
     fw = sub.add_parser("fit-wallet-skill", help="fit the wallet-skill tables' hold and lookback by the selector's objective (one-off, many hours, resumable)")
     fw.add_argument("--days", type=int, default=None, help="most recent days only (default: the whole corpus)"); fw.set_defaults(fn=_cmd_fit_wallet_skill)
     sub.add_parser("pumpstream").set_defaults(fn=_cmd_pumpstream)
+    rc = sub.add_parser("relay-check", help="connect to the stream relay (STREAM_RELAY_URL) for a while and report what arrives; switches nothing")
+    rc.add_argument("--seconds", type=float, default=30.0); rc.set_defaults(fn=_cmd_relay_check)
     sub.add_parser("build-corpus-features").set_defaults(fn=_cmd_build_corpus_features)
     sub.add_parser("assemble-replay").set_defaults(fn=_cmd_assemble_replay)
     sub.add_parser("build-corpus-meta").set_defaults(fn=_cmd_build_corpus_meta)
     sub.add_parser("build-mature").set_defaults(fn=_cmd_build_mature)
+    p_rc = sub.add_parser("rh-build-corpus", help="build the due Robinhood Chain corpus days (the stream starts it as a child process)")
+    p_rc.add_argument("--days", type=int, default=31, help="days at most per run (each run reads every minute's fee once)")
+    p_rc.set_defaults(fn=_cmd_rh_build_corpus)
+    p_v4 = sub.add_parser("rh-v4-backfill", help="import every Robinhood Chain v4 pool key, then backfill the live v4 pools' history (run apart from the console, under nice)")
+    p_v4.add_argument("--no-keys", action="store_true", help="skip the pool-key import")
+    p_v4.add_argument("--no-history", action="store_true", help="skip the live pools' history")
+    p_v4.set_defaults(fn=_cmd_rh_v4_backfill)
+    sub.add_parser("refetch-archive", help="download older archive hours again to keep every venue's SOL legs (run apart from the console, under nice)").set_defaults(fn=_cmd_refetch_archive)
     sub.add_parser("selector-eval").set_defaults(fn=_cmd_selector_eval)
     ts_ = sub.add_parser("train-selector"); ts_.add_argument("--days", type=int, default=None, help="most recent days only (default: the whole corpus)")
     ts_.set_defaults(fn=_cmd_train_selector)

fly_trader/agent/fly_live.py

@@ -82,6 +82,7 @@ class LiveMirror:
         self.mark_lock = threading.Lock()     # the worker's thread and the engine's both mark
         self.last_mark: dict | None = None
         self.wallet_sol: float | None = None
+        self.sale_waits: dict[int, list] = {}   # decision id -> [Event, result]: an operator's Sell Now waiting for its sale (``sell_now``)
         self.worker.on_done = self._after_order
 
     def _decision(self, conn, m1, run_id, beat_id, p, reason: str, forced: bool) -> int:
@@ -119,9 +120,14 @@ class LiveMirror:
                                               slippage_bps=config.SLIPPAGE_ENTRY_BPS, max_slippage_bps=config.MAX_SLIPPAGE_ENTRY_BPS, decimals=int(e["info"]["decimals"] or 6),
                                               size_sol=size, hold_s=e.get("hold_s"), strategy=e.get("strategy"), ref_price=e.get("ref_price"), retry=retry))
 
-    def _sell(self, p: dict, did: int, slip: int) -> bool:
+    def read_balance(self) -> int:
+        """The wallet's SOL (lamports); started beside the minute's scoring by live_first.prefetch."""
+        return int(self.broker.rpc.get_balance(self.broker.pubkey))
+
+    def _sell(self, p: dict, did: int, slip: int, forced_kind: str | None = None) -> bool:
         return self.worker.submit(ExecRequest(decision_id=did, mint=p["mint"], pool=p["pool"], side="sell", amount_in=int(p["qty"]), slippage_bps=slip,
-                                              max_slippage_bps=config.SLIPPAGE_FORCED_BPS, decimals=int(p.get("decimals") or 6), position_id=int(p["id"])))
+                                              max_slippage_bps=config.SLIPPAGE_FORCED_BPS, decimals=int(p.get("decimals") or 6), position_id=int(p["id"]),
+                                              forced_kind=forced_kind))
 
     def _held(self, p: dict, m1: datetime) -> tuple[float, float]:
         """(seconds held, its hold): from its entry decision's minute (paper's clock), not from its fill. A position that
@@ -162,11 +168,39 @@ class LiveMirror:
             record_event("error", "fly_live", f"kill switch: liquidating {n_liq} open live position(s)", {"positions": n_liq})
         return {"exited": n_exit, "liquidated": n_liq}
 
-    def minute(self, ctx, *, run_id: str, beat_id: int, entries: list, line: float, table: list | None) -> dict:
+    def sell_now(self, conn, position_id: int) -> int:
+        """The operator's Sell Now (the console's open positions, agent/live_first.sell_now): one open position of this book
+        sold at once, at the exit's slippage stepping up to the forced one, and booked by the worker like any exit, as a
+        forced 'operator' exit (the live-vs-paper gap and the fly's fill pathway leave it out). Its decision id; ValueError
+        with the reason when nothing was sent (the caller's transaction then rolls its decision back)."""
+        with self.exit_lock:                     # the clock's boundary sales check the same in-flight set: one sale per position
+            p = next((p for p in ledger.open_positions(conn, BOOK) if int(p["id"]) == int(position_id)), None)
+            if p is None:
+                raise ValueError("this position is no longer open")
+            if p["mint"] in self.worker.pending():
+                raise ValueError("an order of this token is already queued or in flight")
+            did = self._decision(conn, datetime.now(timezone.utc), None, None, p, "sold now by the operator", True)
+            self.sale_waits[did] = [threading.Event(), None]
+            if not self._sell(p, did, config.SLIPPAGE_EXIT_BPS, "operator"):
+                self.sale_waits.pop(did, None)
+                raise ValueError("an order of this token is already queued or in flight")
+        return did
+
+    def sale_result(self, did: int, timeout: float):
+        """The worker's result of a ``sell_now`` sale once booked, waiting at most ``timeout`` s (None: not yet)."""
+        w = self.sale_waits.get(did)
+        if w is None:
+            return None
+        w[0].wait(timeout)
+        self.sale_waits.pop(did, None)
+        return w[1]
+
+    def minute(self, ctx, *, run_id: str, beat_id: int, entries: list, line: float, table: list | None, rebuy: dict | None = None) -> dict:
         """The minute's entries, sent the moment the fly has decided (agent/fly_session.FlyBook.on_minute): the worker's
         results first (a failed buy is kept for another try), the minute's sales if the clock has not sent them, then the
-        retries and the paper entries. The wallet is read only when there is something to buy; the wealth mark waits for
-        ``idle``."""
+        retries and the paper entries. A retry goes out only where this minute would buy its token again (``rebuy``,
+        agent/paper_trading.plan_minute), on this minute's score and against this minute's price, never its decision's.
+        The wallet is read only when there is something to buy; the wealth mark waits for ``idle``."""
         conn, m1 = ctx.conn, ctx.m1
         drained = self.worker.drain()
         for r in drained:
@@ -181,7 +215,7 @@ class LiveMirror:
         blocked = "kill switch" if c.kill_switch else "circuit tripped" if rails.breaker_blocks(c) else "paused" if c.entries_paused else None
         n_enter = n_retry = 0; skipped = []
         if self.failed or entries:
-            sol_free = self.broker.rpc.get_balance(self.broker.pubkey) / config.LAMPORTS_PER_SOL; self.wallet_sol = sol_free
+            sol_free = live_first.take_balance(self, ctx.m1_epoch) / config.LAMPORTS_PER_SOL; self.wallet_sol = sol_free
             reserved = treasury = 0.0
             if config.VAULT_ENABLED:                 # SOL owed to vault lockers is never traded; the treasury's idle SOL is bankroll
                 from ..vault import nav as vault_nav
@@ -195,13 +229,16 @@ class LiveMirror:
                 if over:
                     self.failed.pop(did); skipped.append((e["mint"], "retries exhausted"))
                     self._blocked(conn, ctx, run_id, beat_id, e, "retries exhausted", f"{over}; last error: {(f.get('error') or '')[:200]}", tries=f["tries"]); continue
-                rail = blocked or ("stale minute" if stale else None) or ("held" if e["mint"] in held_mints else None)
+                v = (rebuy or {}).get(e["mint"]) or {"why": "not scored this minute"}       # this minute's verdict on buying it again
+                e = {**e, **{k: v[k] for k in ("score", "threshold", "table", "ref_price") if k in v}}   # its score and price now, not its decision's
+                rail = blocked or ("stale minute" if stale else None) or ("held" if e["mint"] in held_mints else None) or (None if "ref_price" in v else "no longer a buy")
                 size, why = (0.0, "") if rail else sizing.size_position(e["score"], e.get("threshold", line), e.get("table") or table or [], bankroll, cash,
                                                                         ctx.resqs.get(e["mint"]) or e["info"]["resq"], flat=config.FLY_SIZING == "flat")
                 if rail or size <= 0:
-                    skipped.append((e["mint"], rail or why)); self._blocked(conn, ctx, run_id, beat_id, e, rail or "sizing", f"retry not sent: {rail or why}", size, retry=True); continue
+                    why = v["why"] if rail == "no longer a buy" else rail or why
+                    skipped.append((e["mint"], why)); self._blocked(conn, ctx, run_id, beat_id, e, rail or "sizing", f"retry not sent: {why}", size, retry=True); continue
                 if self._buy(e, size, retry=f["tries"]):
-                    self.failed.pop(did); self.sent[did] = {**f, "tries": f["tries"] + 1}
+                    self.failed.pop(did); self.sent[did] = {**f, "e": e, "tries": f["tries"] + 1}
                     n_enter += 1; n_retry += 1; cash -= size; held_mints.add(e["mint"])
             for e in entries:
                 if e["mint"] in held_mints:
@@ -295,6 +332,9 @@ class LiveMirror:
             except Exception:
                 log.warning("live mark after an order failed", exc_info=True)
         live_first.changed()
+        w = self.sale_waits.get(res.request.decision_id) if res is not None else None
+        if w is not None:                        # an operator's Sell Now waiting for this sale (``sell_now``)
+            w[1] = res; w[0].set()
 
     def mark_due(self, conn=None, force: bool = False) -> dict | None:
         """The waiting minute's wealth mark: wallet SOL + open positions net of exit cost at the minute's prices, and the
@@ -363,10 +403,12 @@ class LiveMirror:
             self.worker.busy.release()
 
     def gap(self, conn) -> dict:
-        """Live vs its paper mirror on the same decisions; pauses entries when live trails by more than ``GAP_MAX`` per trade."""
+        """Live vs its paper mirror on the same decisions; pauses entries when live trails by more than ``GAP_MAX`` per trade.
+        An operator's Sell Now (forced 'operator') is the operator's choice, not an execution gap: left out."""
         rows = conn.execute(f"""SELECT l.realized_sol / NULLIF(l.cost_sol, 0) AS rl, p.realized_sol / NULLIF(p.cost_sol, 0) AS rp
                                FROM positions l JOIN positions p ON p.entry_decision_id = l.entry_decision_id AND p.book = '{MIRROR}' AND p.status = 'closed'
-                               WHERE l.book = '{BOOK}' AND l.status = 'closed' AND l.entry_decision_id IS NOT NULL ORDER BY l.closed_at DESC LIMIT %s""", (GAP_TRADES,)).fetchall()
+                               WHERE l.book = '{BOOK}' AND l.status = 'closed' AND l.entry_decision_id IS NOT NULL AND COALESCE(l.forced_exit_kind, '') <> 'operator'
+                               ORDER BY l.closed_at DESC LIMIT %s""", (GAP_TRADES,)).fetchall()
         rl = np.array([r["rl"] for r in rows if r["rl"] is not None and r["rp"] is not None], dtype=np.float64)
         rp = np.array([r["rp"] for r in rows if r["rl"] is not None and r["rp"] is not None], dtype=np.float64)
         out = {"trades": int(len(rl)), "live_mean": float(rl.mean()) if len(rl) else None, "mirror_mean": float(rp.mean()) if len(rp) else None}

fly_trader/agent/fly_session.py

@@ -6,11 +6,16 @@ learning rate and forgetting of its mushroom body (``brain/plastic.py``). Each m
 first (CLAUDE.md): ``on_minute`` runs before any other book's minute, ``after_minute`` once every chain's live orders are out.
 
 1. bars: minute start, open, close and exit cost of every traded mint with a pending tag feed the label resolver;
-2. scoring (``on_minute``): eligible minutes are scored by the plastic fly and its shadow and tagged; only minutes at or
-   above the line teach it (brain/plastic.py);
+2. scoring: with the teacher gate on, ``on_minute`` takes the teacher's decision from one pass of its stack and the fly
+   scores only the rows the teacher would trade, its learned veto's input (``_decide``); every eligible row's plastic and
+   shadow score and its tag wait for ``after_minute`` (``_score`` on the same pass). Ungated, or at a session's first
+   scored minute (the readout's ν, the fill pathways need every row), ``on_minute`` scores and tags every row (``_score``).
+   Only minutes at or above the line teach it (brain/plastic.py);
 3. trading (``on_minute``; fresh stream, trade minutes): the race rules (``agent/paper_trading.py``) at the plastic line
-   and sizing plan the paper book's minute, and once the fly holds the seat the wallet's orders on its entries go out
-   (agent/fly_live.py, rh/live.py; the wallet's scheduled sales left at the minute boundary, agent/live_first.py);
+   and sizing plan the paper book's minute, and the wallet's orders go out on the seat holder's decision (agent/fly_live.py,
+   rh/live.py; the wallet's scheduled sales left at the minute boundary, agent/live_first.py): the fly's once it holds the
+   seat; before that (LIVE_WITHOUT_HANDOVER) the selector's -- the fly's learned veto binds only its paper book, which is
+   what its race measures;
 4. after the live orders (``after_minute``): the scored rows stored (``fly_scored``: pending rows keep the feature
    vector, so tags survive restarts), the paper trades booked, then outcomes: tags whose exit minute has now been seen
    teach the mushroom body's outcome pathway what the row made -- the book's realized return when it traded the row,
@@ -34,6 +39,7 @@ import json
 import logging
 import math
 import os
+import threading
 import time
 import uuid
 from collections import deque
@@ -145,6 +151,7 @@ class FlyBook:
     def __init__(self, boot: dict, verdict: dict, live: bool = False, chain: str = "sol", brain: "FlyBook | None" = None):
         self.live = live; self.done = False
         self._phase: dict | None = None; self._scored_rows: list = []; self._activity: tuple | None = None   # the live phase's, written after it
+        self._live_pass: tuple | None = None     # (minute, teacher decision, teacher scores) the live phase decided on (_decide)
         self.verdict = verdict
         self.chain = chain; self.market = markets.for_chain(chain); self.brain = brain
         self.name = "fly" if chain == "sol" else f"fly_{chain}"
@@ -156,6 +163,7 @@ class FlyBook:
             conn.execute("INSERT INTO runs (run_id, kind, config, brain_snapshot_id, status) VALUES (%s,%s,%s,%s,'running')",
                          (self.run_id, self.KIND, json.dumps({"channels": self.cfg, "book": self.BOOK, "chain": chain}, default=str), self.boot_id))
             self._restore_tags(conn)
+            self.has_seat = handover.state(conn, chain) is not None     # whose decision the wallet trades (on_minute); refreshed after each minute's live orders
         record_event("info", "fly", "fly session started", {"run_id": self.run_id, "bootstrap": self.boot_id, "channels": self.cfg, "lines": self.lines["plastic"],
                                                             "pending": len(self.pending), "learning_frozen": self.learning_frozen})
         log.info("fly session: bootstrap %d on %s, channels %s, lines %s, %d pending tags", self.boot_id, brain_device.describe(self.fly.net.dev), self.cfg,
@@ -166,13 +174,14 @@ class FlyBook:
         b = self.brain
         if b is not None:        # another chain's book: the Solana book's fly and plastic memory, this chain's own lines and tags
             self.boot_id = b.boot_id; self.fly = b.fly; self.connectome_name = b.connectome_name; self.capture_ok = False
+            self.fly_lock = b.fly_lock                       # the chains' live phases run at once: one model, one at a time
             self.teacher_models = b.teacher_models; self.idx = b.idx; self.names = b.names; self.holds = b.holds; self.H = b.H
             self.teacher_live, self.teacher_groups = b.teacher_live, b.teacher_groups
             self.cfg = b.cfg; self.alpha = b.alpha; self.half_life = b.half_life; self.bank = b.bank
             net = self.fly.net
         else:
             self.boot_id = int(boot["id"])
-            self.fly = fly_selector.load(boot["path"])
+            self.fly = fly_selector.load(boot["path"]); self.fly_lock = threading.Lock()
             try:
                 self.connectome_name = current_connectome_path().name       # stamped on the activity files the console draws
             except Exception:
@@ -421,20 +430,29 @@ class FlyBook:
         are out."""
         conn = ctx.conn; self._phase = None
         self._commands(conn, ctx.m1_epoch)
-        scored = self._score(conn, ctx)
+        if self._fast():
+            scored = self._decide(ctx)
+        else:
+            with self.fly_lock:                              # every row on the model another chain's live phase may be using
+                scored = self._score(conn, ctx)
+        timing = {"seen_s": ctx.lag_s, "scored_s": time.time() - ctx.m1_epoch}    # after the minute's end: the engine had its rows, the fly decided
         plan = live = None
         if ctx.trade and ctx.fresh:
             if self.race_started_at is None:
                 self.race_started_at = ctx.m1_epoch
             self.beat_no += 1
-            d = scored["decision"]
+            d = scored["decision"]; vetoed = d.get("vetoed")
+            # until the fly has won its race the selector holds the seat: its decision goes live, and the fly's learned veto
+            # binds only the paper book (the race measures it)
+            live_allow = d["allow"] | vetoed if vetoed is not None and vetoed.any() and not self.has_seat else None
             plan = paper_trading.plan_minute(ctx, book=self.BOOK, run_id=self.run_id, beat_no=self.beat_no, broker=self.broker, kind=self.KIND, mints=ctx.mints,
                                              infos=ctx.infos, scores=d["score"], threshold=d["threshold"], table=None, horizon_s=self.holds[self.names[0]],
                                              holds=d["hold_s"], strategies=d["strategy"], tables=d["tables"], flat=config.FLY_SIZING == "flat",
-                                             allow=d.get("allow"), reasons=d.get("reason"))
+                                             allow=d.get("allow"), reasons=d.get("reason"), live_allow=live_allow)
             if self.trades_live(conn):
-                live = self._go_live(ctx, plan["beat_id"], plan["entries"])
-        self._phase = {"m1": ctx.m1, "picks": scored["picks"], "plan": plan, "live": live}
+                live = self._go_live(ctx, plan["beat_id"], plan["entries"], plan["rebuy"])
+                timing["orders_s"] = time.time() - ctx.m1_epoch                          # the wallet's orders queued
+        self._phase = {"m1": ctx.m1, "picks": scored["picks"], "plan": plan, "live": live, "timing": timing}
         return {"minute": ctx.m1.isoformat(), "picks": scored["picks"], "live": live}
 
     def after_minute(self, ctx) -> dict:
@@ -444,6 +462,9 @@ class FlyBook:
         conn = ctx.conn
         ph = self._phase if self._phase is not None and self._phase["m1"] == ctx.m1 else {"picks": 0, "plan": None, "live": None}
         self._phase = None
+        lp, self._live_pass = self._live_pass, None
+        if lp is not None and lp[0] == ctx.m1:           # the live phase decided on its teacher's pass: every row's score and tag now
+            self._score(conn, ctx, live_pass=lp[1:])
         self._store_scored(conn)
         st = paper_trading.book_minute(ctx, ph["plan"]) if ph["plan"] is not None else None
         learned = self._learn(conn, ctx.m1_epoch)
@@ -459,7 +480,7 @@ class FlyBook:
                "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)}
+               "device": str(self.fly.net.dev), "timing": ph.get("timing")}
         if st is not None:
             out.update({k: v for k, v in st.items() if k != "entries"}); out["stage"] = "trading"
             if ph["live"] is not None:
@@ -471,6 +492,7 @@ class FlyBook:
             self.last_hour = hour
         elif hour > self.last_hour:
             self.last_hour = hour; self._hourly(conn, ctx.m1_epoch)
+        self.has_seat = handover.state(conn, self.chain) is not None     # for the next live phase: a handover, or the seat cleared by hand
         self._write_capture()
         self._write_state()
         if learned.get("keys"):          # a row still waiting for its live fill keeps its features (tags survive restarts)
@@ -502,26 +524,26 @@ class FlyBook:
         """The chain's live mirror, one per process and owned by the runner (agent/live_first.py); None until made."""
         return live_first.mirror_of(self.chain)
 
-    def _go_live(self, ctx, beat_id: int, entries: list) -> dict:
+    def _go_live(self, ctx, beat_id: int, entries: list, rebuy: dict) -> dict:
         """The wallet's orders of this minute, in their own savepoint: a wallet RPC timeout must not roll back the paper plan."""
         try:
             with ctx.conn.transaction():
-                return self._live(ctx, beat_id, entries)
+                return self._live(ctx, beat_id, entries, rebuy)
         except Exception as e:
             log.exception("%s: live minute %s failed; the paper minute stands", self.name, ctx.m1.isoformat())
             record_event("error", "fly_live", f"live minute failed: {type(e).__name__}: {str(e)[:160]}", {"chain": self.chain, "minute": ctx.m1.isoformat()})
             return {"stage": f"live minute failed: {type(e).__name__}"}
 
-    def _live(self, ctx, beat_id: int, entries: list) -> dict:
+    def _live(self, ctx, beat_id: int, entries: list, rebuy: dict) -> dict:
         """Mirror this minute's entries on the bot wallet (agent/fly_live.py; Robinhood Chain: the ETH wallet, rh/live.py)
-        while signing is allowed."""
+        while signing is allowed; a failed entry goes again only where this minute would buy its token again (``rebuy``)."""
         why = self._signing()
         if why:
             return {"stage": f"live gated: {why}"}
         mirror = live_first.mirror(self.chain, self.H)          # the clock may have made it while this book was loading
         if self.chain != "sol":
-            return mirror.minute(ctx, run_id=self.run_id, beat_id=beat_id, entries=entries)
-        return mirror.minute(ctx, run_id=self.run_id, beat_id=beat_id, entries=entries, line=self.lines["plastic"][self.names[0]],
+            return mirror.minute(ctx, run_id=self.run_id, beat_id=beat_id, entries=entries, rebuy=rebuy)
+        return mirror.minute(ctx, run_id=self.run_id, beat_id=beat_id, entries=entries, rebuy=rebuy, line=self.lines["plastic"][self.names[0]],
                              table=self.sizing["plastic"][self.names[0]])
 
     def _live_after(self, ctx, beat_id: int) -> dict:
@@ -648,8 +670,9 @@ class FlyBook:
             return {}, {}
         ts = sorted({datetime.fromtimestamp(t + 60.0, timezone.utc) for t, _, _ in keys}); mints = sorted({m for _, m, _ in keys})
         rows = conn.execute("SELECT d.ts, d.mint, d.detail->>'strategy' AS strategy, p.book, p.status, p.realized_sol / NULLIF(p.cost_sol, 0) AS ret "
-                            "FROM decisions d JOIN positions p ON p.entry_decision_id = d.id AND p.book = ANY(%s) "     # an aborted RH buy (no tokens, gas only) was no trade
-                            "AND COALESCE(p.forced_exit_kind, '') <> 'aborted' WHERE d.kind = %s AND d.ts = ANY(%s) AND d.mint = ANY(%s)",
+                            "FROM decisions d JOIN positions p ON p.entry_decision_id = d.id AND p.book = ANY(%s) "     # an aborted RH buy (no tokens, gas only) was no trade,
+                            "AND COALESCE(p.forced_exit_kind, '') NOT IN ('aborted', 'operator') "                    # an operator's Sell Now no fill of the fly's
+                            "WHERE d.kind = %s AND d.ts = ANY(%s) AND d.mint = ANY(%s)",
                             ([self.BOOK, self.market.live_book], f"{self.KIND}_enter", ts, mints)).fetchall()
         book: dict = {}; live: dict = {}
         for r in rows:
@@ -657,7 +680,44 @@ class FlyBook:
             (book if r["book"] == self.BOOK else live)[key] = (r["status"], float(r["ret"]) if r["status"] == "closed" and r["ret"] is not None else None)
         return book, live
 
-    def _score(self, conn, ctx) -> dict:
+    def _fast(self) -> bool:
+        """Whether the live phase decides on its teacher's pass alone (``_decide``): the gate is on with its teacher loaded,
+        and no one-time choice of the session (the readout's ν, the fill pathways) needs every row of the minute first."""
+        return bool(config.FLY_TEACHER_GATE) and self.teacher_live is not None and self.nu_set and not self.fill_choice
+
+    def _decide(self, ctx) -> dict:
+        """The live phase's scoring (live money first, CLAUDE.md): one pass of the teacher's stack over the minute's rows
+        gives its decision and its scores, then the fly scores only the rows its teacher would trade -- the input of its
+        learned veto, the one place its score decides. Every other row's score, the tags that teach the fly, the brain view
+        and the blind teacher's budget wait for ``after_minute`` (``_score`` on this pass). The decision is ``_score``'s."""
+        n = len(ctx.mints)
+        if not n:
+            return self._score(ctx.conn, ctx)
+        per = strategies.decide_all(self.teacher_live, ctx.X, X_COLS, ctx.t_start)
+        td = self._teacher_decision(ctx, per)
+        tv = fly_selector.teacher_scores_of(per, self.names, n) if config.FLY_SCORE == "teacher" else None
+        V = np.full((n, len(self.names)), -np.inf); F = np.full((n, len(self.names)), np.nan)
+        need = np.asarray([i for i in range(n) if td["allow"][i] and td["strategy"][i] in self.names], dtype=int)
+        if len(need):
+            Xn = ctx.X[need]; trig = self.fly.triggers(Xn, X_COLS)
+            with self.fly_lock:                               # another chain's live phase may be scoring on the same model
+                Y, u0, k = self.fly.parts_all(Xn[:, self.idx])
+                for j, name in enumerate(self.names):         # as _score: the row's strategy, where the fly's trigger fires and its teacher scores it
+                    q = np.asarray([p for p, i in enumerate(need) if td["strategy"][i] == name and trig[p, j] and (tv is None or np.isfinite(tv[i, j]))], dtype=int)
+                    if not len(q):
+                        continue
+                    li = torch.as_tensor(q, device=Y.device); s = np.full(len(q), j)
+                    y = self._head(Y[li, j], tv, need[q], j, u0[li])
+                    with torch.no_grad():
+                        sc, _ = self.bank.predict(y, u0[li], k[li], s=s); fr = self.bank.frozen(y, u0[li], s=s)
+                    V[need[q], j] = sc[0].float().cpu().numpy(); F[need[q], j] = fr.float().cpu().numpy()
+        self._live_pass = (ctx.m1, td, tv)
+        d = self._gated(ctx, V, F, td)
+        return {"decision": d, "picks": int(d["allow"].sum())}
+
+    def _score(self, conn, ctx, live_pass: tuple | None = None) -> dict:
+        """Every eligible row scored by the plastic fly and its shadow and tagged, and the minute's decision. ``live_pass``:
+        (teacher decision, teacher scores) the live phase already decided on (``_decide``), reused."""
         n = len(ctx.mints); empty = {"strategy": np.full(n, None, dtype=object), "score": np.full(n, -1.0), "hold_s": np.zeros(n), "threshold": np.full(n, np.inf),
                                      "tables": [[] for _ in range(n)]}
         if not n:
@@ -675,8 +735,11 @@ class FlyBook:
         gated = config.FLY_TEACHER_GATE
         if config.FLY_SCORE == "teacher" and self.teacher_live is None:      # it starts from its teacher's score: none, no score
             return {"decision": no_teacher(n), "picks": 0}
-        td = self._teacher_decision(ctx) if gated and self.teacher_live is not None else None
-        tv = self._teacher_scores(ctx.X, t)
+        if live_pass is not None:
+            td, tv = live_pass
+        else:
+            td = self._teacher_decision(ctx) if gated and self.teacher_live is not None else None
+            tv = self._teacher_scores(ctx.X, t)
         for j, name in enumerate(self.names):
             loc = np.flatnonzero(trig[:, j])
             if tv is not None:
@@ -734,20 +797,23 @@ class FlyBook:
             return y_own
         return self.bank.head_for(torch.as_tensor(tv[loc, j], dtype=torch.float32, device=self.bank.dev), u0, s=np.full(len(loc), j))
 
-    def _teacher_decision(self, ctx) -> dict:
-        """The deployed selector's decision on this minute's rows, with its live fail-closed rules."""
+    def _teacher_decision(self, ctx, per: dict | None = None) -> dict:
+        """The deployed selector's decision on this minute's rows, with its live fail-closed rules. ``per``: its stack's
+        ``decide_all`` on them, when the caller has it."""
         from .selector_session import fail_closed
-        return fail_closed(self.teacher_groups, ctx.infos, strategies.decide(self.teacher_live, ctx.X, X_COLS, ctx.t_start))
+        kw = {} if per is None else {"per": per}
+        return fail_closed(self.teacher_groups, ctx.infos, strategies.decide(self.teacher_live, ctx.X, X_COLS, ctx.t_start, **kw))
 
     def _gated(self, ctx, V: np.ndarray, F: np.ndarray, td: dict | None = None) -> dict:
         """The fly's decision under its teacher: each row's strategy, trigger, line, win filter, gates, dump veto and
         fail-closed rules are the deployed selector's (agent/selector_session.fail_closed), so a fresh bootstrap trades the
         selector's set; the fly drops a teacher trade only where its learning has moved its score more than
-        ``FLY_LEARNED_VETO`` below its bootstrap score. A row the teacher blocks is recorded with the teacher's reason."""
+        ``FLY_LEARNED_VETO`` below its bootstrap score (``vetoed``: those rows, which go live as the selector decided them
+        while it holds the seat, ``on_minute``). A row the teacher blocks is recorded with the teacher's reason."""
         n = len(ctx.mints)
         td = td if td is not None else self._teacher_decision(ctx)
         strat = np.full(n, None, dtype=object); score = np.full(n, -1.0); hold = np.zeros(n); thr = np.full(n, np.inf)
-        tables = [[] for _ in range(n)]; allow = np.zeros(n, bool); reason = np.full(n, "", dtype=object)
+        tables = [[] for _ in range(n)]; allow = np.zeros(n, bool); vetoed = np.zeros(n, bool); reason = np.full(n, "", dtype=object)
         for i in range(n):
             s_ = td["strategy"][i]
             if s_ is None or s_ not in self.names:
@@ -759,10 +825,10 @@ class FlyBook:
             if not td["allow"][i]:
                 reason[i] = f"selector: {td['reason'][i]}"
             elif np.isfinite(v) and np.isfinite(f) and v < f - config.FLY_LEARNED_VETO:
-                reason[i] = f"learned veto: score {v:.3f} < bootstrap {f:.3f} - {config.FLY_LEARNED_VETO:g}"
+                reason[i] = f"learned veto: score {v:.3f} < bootstrap {f:.3f} - {config.FLY_LEARNED_VETO:g}"; vetoed[i] = True
             else:
                 allow[i] = True; reason[i] = "trade"
-        return {"strategy": strat, "score": score, "hold_s": hold, "threshold": thr, "tables": tables, "allow": allow, "reason": reason}
+        return {"strategy": strat, "score": score, "hold_s": hold, "threshold": thr, "tables": tables, "allow": allow, "vetoed": vetoed, "reason": reason}
 
     def _capture(self, H: torch.Tensor, trig: np.ndarray, t: float) -> None:
         """The console's brain view: this minute's mean activity over the rows some strategy's trigger fired on (every

fly_trader/agent/live_first.py

@@ -1,8 +1,12 @@
 """Live money first and fast over paper, always (CLAUDE.md): when the live books' work runs.
 
 - ``LiveClock``: the live chains' sales due at a minute boundary go out the moment it passes, from a thread of their own
-  (``runner-live-clock``), started with the runner -- before its books load and the engine warms up, so a restart never
-  holds a sale back -- and at once for the minute it starts in (a restart may have straddled a boundary).
+  (``runner-live-clock``), every chain's side by side, started with the runner -- before its books load and the engine
+  warms up, so a restart never holds a sale back -- and at once for the minute it starts in (a restart may have
+  straddled a boundary).
+- Anything that can run beside a live order does: the engine wakes the moment a stream writes a minute
+  (``minute_published``), each chain's wallet balance is read while its minute's features and scores are computed
+  (``prefetch``), and the chains' live phases run at once (agent/minute_engine.run_ready).
 - One live mirror per chain per process (``mirror``): made by whichever comes first, the clock at a boundary or the
   fly's first live minute, and stopped by the runner when it stops (``stop_mirrors``), never by a book.
 - The engine runs every chain's newest minute for its live books first (the fly scores, its paper book plans, the
@@ -21,6 +25,7 @@ import logging
 import math
 import threading
 import time
+from concurrent.futures import ThreadPoolExecutor
 from datetime import datetime, timezone
 
 from .. import config
@@ -33,6 +38,35 @@ MID_MINUTE = (20.0, 40.0)     # seconds into a minute when slow wallet bookkeepi
 _MIRRORS: dict[str, object] = {}
 _MIRRORS_LOCK = threading.Lock()
 _LISTENERS: list = []
+_PUBLISHED = threading.Event()
+_PREFETCH = ThreadPoolExecutor(max_workers=2, thread_name_prefix="runner-prefetch")   # the live minutes' wallet reads
+_CLOCK = ThreadPoolExecutor(max_workers=4, thread_name_prefix="runner-live-clock")    # every chain's boundary sales at once
+
+
+def minute_published() -> None:
+    """A chain's stream has written a minute (ingest/pumpstream.py, rh/minutes.py): the engine's loop wakes at once."""
+    _PUBLISHED.set()
+
+
+def wait_published(timeout: float) -> None:
+    """The engine's loop between polls: back at the next published minute, else after ``timeout``."""
+    _PUBLISHED.wait(timeout)
+    _PUBLISHED.clear()
+
+
+def prefetch(chain: str, live: bool, m1_epoch: float) -> None:
+    """At a live minute's start, the chain's wallet balance read starts on its own thread, beside the minute's features
+    and the fly's scoring; the mirror sizes the minute's entries on it (``take_balance``)."""
+    m = _MIRRORS.get(chain)
+    if m is None or not live or not hasattr(m, "read_balance") or signing_refused(chain):
+        return
+    m.balance_ahead = (m1_epoch, _PREFETCH.submit(m.read_balance))
+
+
+def take_balance(m, m1_epoch: float):
+    """The balance ``prefetch`` started for this minute (its error raised here), else read now."""
+    ahead, m.balance_ahead = getattr(m, "balance_ahead", None), None
+    return ahead[1].result() if ahead is not None and ahead[0] == m1_epoch else m.read_balance()
 
 
 def may_mark(now: float | None = None) -> bool:
@@ -116,6 +150,30 @@ def chain_exits(chain: str, m1_epoch: float, live: bool, run_id: str | None = No
         return mirror(chain).exits(conn, m1=datetime.fromtimestamp(m1_epoch, timezone.utc), run_id=run_id)
 
 
+SELL_NOW_WAIT_S = 90.0        # how long the operator's Sell Now waits for its sale to be booked (an RH sale can take a minute)
+
+
+def sell_now(chain: str, position_id: int, wait_s: float = SELL_NOW_WAIT_S) -> dict:
+    """The operator's Sell Now (the console's open positions, ui/api/overview.py): the chain's mirror sells one open live
+    position at once (its ``sell_now``), then this waits up to ``wait_s`` for the sale to be booked. {"booked", "realized",
+    "cost", "error"} (not booked and no error: not filled yet); ValueError with the reason when nothing was sent."""
+    m = mirror_of(chain)
+    if m is None:
+        raise ValueError("this chain's live mirror is not running in this console")
+    why = signing_refused(chain)
+    if why:
+        raise ValueError(f"its wallet may not sign: {why}")
+    with transaction() as conn:
+        did = m.sell_now(conn, position_id)
+    res = m.sale_result(did, wait_s)
+    with transaction() as conn:
+        p = conn.execute("SELECT status, realized_sol, cost_sol FROM positions WHERE id = %s", (position_id,)).fetchone()
+    booked = p is not None and p["status"] == "closed"
+    return {"booked": booked, "realized": float(p["realized_sol"]) if booked and p["realized_sol"] is not None else None,
+            "cost": float(p["cost_sol"]) if p is not None else None,
+            "error": None if booked or res is None else (res.error or "it sold only part of the position: the rest stays open")}
+
+
 def idle_mirrors() -> None:
     """Between minutes: each mirror's bookkeeping that waits for an idle wallet (the wealth mark, sweeps, the reconcile)."""
     for chain, m in list(_MIRRORS.items()):
@@ -164,17 +222,21 @@ class LiveClock:
             self.tick(math.floor(time.time() / 60.0) * 60.0)        # the boundary just passed (a late wake takes the newest)
 
     def tick(self, m1_epoch: float) -> None:
-        for chain in self.chains:
-            run_id = next((b.run_id for b in list(self.books) if getattr(b, "LIVE", False) and getattr(b, "chain", "sol") == chain), None)
-            try:
-                out = chain_exits(chain, m1_epoch, self.live, run_id)
-                n = (out or {}).get("exited", 0) + (out or {}).get("liquidated", 0)
-                if n:
-                    log.info("%s: %d live sale(s) sent at the minute boundary", chain, n)
-            except Exception as e:
-                log.exception("%s: live exits at the minute boundary failed", chain)
-                record_event("error", "fly_live" if chain == "sol" else "rh_live", f"live exits at the minute boundary failed: {type(e).__name__}: {str(e)[:160]}",
-                             {"chain": chain})
+        """Every live chain's sales due at the boundary, the chains side by side: one chain's slow reads never hold
+        another's sales back."""
+        list(_CLOCK.map(lambda chain: self._tick(chain, m1_epoch), self.chains))
+
+    def _tick(self, chain: str, m1_epoch: float) -> None:
+        run_id = next((b.run_id for b in list(self.books) if getattr(b, "LIVE", False) and getattr(b, "chain", "sol") == chain), None)
+        try:
+            out = chain_exits(chain, m1_epoch, self.live, run_id)
+            n = (out or {}).get("exited", 0) + (out or {}).get("liquidated", 0)
+            if n:
+                log.info("%s: %d live sale(s) sent at the minute boundary", chain, n)
+        except Exception as e:
+            log.exception("%s: live exits at the minute boundary failed", chain)
+            record_event("error", "fly_live" if chain == "sol" else "rh_live", f"live exits at the minute boundary failed: {type(e).__name__}: {str(e)[:160]}",
+                         {"chain": chain})
 
     def close(self, timeout: float = 10.0) -> None:
         self.stop_flag.set()

fly_trader/agent/minute_engine.py

@@ -17,9 +17,9 @@ savepoint, so one book's failure never undoes the other's minute.
 Live money first and fast over paper, always (CLAUDE.md, agent/live_first.py). A book that trades live money (``LIVE``:
 the fly) runs its minute in two parts: ``on_minute`` in the minute's live phase (``live_phase``: the features, then the
 fly scores, plans and sends the wallet's orders; committed at once), ``after_minute`` in its paper phase
-(``paper_phase``: its paper trades, learning and bookkeeping, then every other book's minute). The loop runs every
-chain's newest minute's live phase before any chain's paper phase, and the live mirrors' idle bookkeeping between
-minutes. The wallet's scheduled sales go out at each minute boundary from the live clock's own thread
+(``paper_phase``: its paper trades, learning and bookkeeping, then every other book's minute). The loop runs the
+chains' newest minutes' live phases at once, before any chain's paper phase (and a minute written during the paper
+phases has its live phase before the next one), and the live mirrors' idle bookkeeping between minutes. The wallet's scheduled sales go out at each minute boundary from the live clock's own thread
 (``live_first.chain_exits``), started with the runner: a restart never holds them behind the books loading or the warm-up.
 
 Books join when they qualify (checked every ``MODEL_CHECK_S``, mid-minute): the selector while it has a deployable
@@ -27,7 +27,7 @@ model and has not handed its seat to a fly that is trading;
 the fly once its design passed the replay and a deployable bootstrap exists. No entries or exits while the stream is
 stale; missed minutes are replayed through the features without trading; a minute traded more than ``ENTRY_MAX_LAG_S``
 after its end (``Minute.lag_s``) takes no entries (agent/paper_trading.py), only exits. A minute runs as soon as its
-stream has written it (polled every ``POLL_S``).
+stream has written it (the stream's publish wakes the loop, live_first.minute_published; else polled every ``POLL_S``).
 """
 from __future__ import annotations
 
@@ -37,6 +37,7 @@ import math
 import threading
 import time
 from collections import deque
+from concurrent.futures import ThreadPoolExecutor
 from dataclasses import dataclass, replace
 from datetime import datetime, timezone
 
@@ -48,7 +49,7 @@ from ..db.connection import transaction
 from ..market.exit_cost import PUMP_SUPPLY
 from ..market.exit_cost import cost_at_size, cost_label
 from ..market.features import FEATURES, FIDX, TokenMeta, TokenState
-from ..train.corpus_meta import FEATURE_COLS as META_COLS
+from ..train.corpus_meta import FEATURE_COLS as META_COLS, sol_select
 from ..train.decisions import MIN_RESQ_SOL, MIN_VOL_15M_SOL, X_COLS
 from ..train.flow import FlowWindow, MarketWindow
 from ..train.mature import MASKED
@@ -57,15 +58,18 @@ from . import live_first
 
 log = logging.getLogger(__name__)
 WARMUP_MIN = 1440            # training warms each day on the previous day's candles
+V4_WARM_H = 3.0              # a plain v4 memecoin trades only once the engine has fed it this long (the longest feature window):
+                             # it goes live mid-session without the history before (rh/v4_universe.go_live)
 IDLE_EVICT_S = 86400         # training has no history for a mint idle since before the previous day
 STREAM_STALE_S = 180         # no entries or exits when the stream's newest complete minute is older than this
 META_TTL_S = 600
 MODEL_CHECK_S = 600          # how often books reload newer models and new books are admitted
-POLL_S = 0.25                # how often the loop looks for a minute its stream has written
+POLL_S = 0.25                # how often the loop looks for a minute its stream has written (a stream's publish wakes it at once)
+_LIVE_POOL = ThreadPoolExecutor(max_workers=4, thread_name_prefix="runner-live")   # every chain's live phase at once
 
 
 class MintState:
-    __slots__ = ("st", "meta", "hist", "decimals", "pool", "program_label", "graduated_at", "meta_row", "prev_close", "broken", "flow", "fee")
+    __slots__ = ("st", "meta", "hist", "decimals", "pool", "program_label", "graduated_at", "meta_row", "prev_close", "broken", "flow", "fee", "first_seen")
 
     def __init__(self, mint: str, decimals: int, pool: str | None, program_label: str | None, graduated_at: float | None, meta_row: dict | None):
         self.st = TokenState(mint); self.meta = TokenMeta(mint=mint, program_label=program_label or "Pump.fun Amm", graduated_at=graduated_at)
@@ -74,6 +78,7 @@ class MintState:
         self.prev_close: float | None = None; self.broken = False
         self.flow = FlowWindow()                    # wallet flow inputs (train/flow.py, as mature.build_day)
         self.fee: float | None = None               # the last pool fee a minute of this mint reported (Minute.fee)
+        self.first_seen: float | None = None        # end of the first minute this engine fed (warm-up included)
 
 
 @dataclass
@@ -151,9 +156,9 @@ class MinuteEngine:
         hit = self.meta_cache.get(mint)
         if hit is None or time.time() - hit["at"] > META_TTL_S:
             if self.rh:                                  # Robinhood Chain: rh_meta, the same columns (rh/meta.py), plus the quote class
-                r = conn.execute("SELECT graduated_at, supply, quote_class, " + ", ".join(META_COLS) + " FROM rh_meta WHERE mint = %s", (mint,)).fetchone()
+                r = conn.execute("SELECT graduated_at, supply, quote_class, source, " + ", ".join(META_COLS) + " FROM rh_meta WHERE mint = %s", (mint,)).fetchone()
             else:
-                r = conn.execute("SELECT graduated_at, supply, " + ", ".join(META_COLS) + " FROM corpus_meta WHERE mint = %s", (mint,)).fetchone()
+                r = conn.execute("SELECT graduated_at, supply, " + sol_select(META_COLS) + " FROM corpus_meta WHERE mint = %s", (mint,)).fetchone()
             hit = self.meta_cache[mint] = {"row": dict(r) if r else None, "at": time.time()}
         return hit["row"]
 
@@ -207,7 +212,8 @@ class MinuteEngine:
 
     # ---- one minute ----
     def _aggregate(self, conn, m0: datetime, m1: datetime) -> dict[str, dict]:
-        """PumpAPI minutes: every SOL-quoted PumpSwap pump.fun token, the same fields as the archive. Robinhood Chain: the
+        """PumpAPI minutes: every pump.fun token's SOL-quoted PumpSwap or Meteora DLMM pool with the most legs that minute, the
+        same fields as the archive. Robinhood Chain: the
         rh_minutes of graduated Pons pools in ETH (rh/minutes.py), under the same keys."""
         if self.rh:
             rows = conn.execute("SELECT mint, pool_id, open, high, low, close, buy_eth, sell_eth, n_buys, n_sells, n_traders, resq_eth, fee_rate, "
@@ -229,6 +235,8 @@ class MinuteEngine:
         """The full feature vector (``X_COLS``) of a mint for the minute ending ``t_end``, and what trading needs."""
         s = self._state(conn, mint, a["pool"], a["program_label"])
         st, price, resq = s.st, float(a["close"]), a["resq"]
+        if s.first_seen is None:
+            s.first_seen = t_end
         if self.rh:
             s.meta.pool_fee = a.get("fee_rate")          # the Pons hook fee this minute charged (the cost model's fee)
         if a.get("fee_rate") is not None:
@@ -267,11 +275,13 @@ class MinuteEngine:
                 "age_h": (t_end - s.graduated_at) / 3600 if s.graduated_at else None,
                 "mcap": price * s.meta.supply, "fee_rate": a.get("fee_rate"), "decimals": s.decimals, "pool": s.pool, "program_label": s.program_label, "broken": s.broken,
                 "skill_missing": a.get("skill_buy") is None, "curve_known": bool(meta.get("curve_known")), "chain": self.spec.chain,
-                "quote_class": meta.get("quote_class")}
+                "quote_class": meta.get("quote_class"), "source": meta.get("source"), "seen_h": (t_end - s.first_seen) / 3600.0}
         return x, info
 
     def eligible(self, info: dict) -> bool:
         if self.rh:                                      # the same gates in the chain's unit (x K), as training (train/decisions)
+            if info.get("source") == "v4" and (info.get("seen_h") or 0.0) < V4_WARM_H:
+                return False                             # its feature windows are not full yet (V4_WARM_H)
             return not info["broken"] and info["resq"] is not None and info["resq"] >= self.spec.min_resq() and info["logvol_15m"] >= math.log1p(self.spec.min_vol_15m())
         return not info["broken"] and info["resq"] is not None and info["resq"] >= MIN_RESQ_SOL and info["logvol_15m"] >= math.log1p(MIN_VOL_15M_SOL)
 
@@ -333,6 +343,9 @@ class MinuteEngine:
         other chain's paper work runs before these orders (live money first, CLAUDE.md)."""
         m1 = datetime.fromtimestamp(m1_epoch, timezone.utc); m0 = datetime.fromtimestamp(m1_epoch - 60, timezone.utc)
         out: dict = {"minute": m1.isoformat()}
+        live_books = [b for b in self.my_books() if getattr(b, "LIVE", False)]
+        if trade and live_books:
+            live_first.prefetch(self.spec.chain, self.live, m1_epoch)      # the wallet's balance, read beside the features and scores
         with transaction() as conn:
             agg = self._aggregate(conn, m0, m1)
             X, infos, mints, bars = self._minute_rows(conn, agg, m1_epoch)
@@ -341,7 +354,7 @@ class MinuteEngine:
                          fees={m: a.get("fee_rate") for m, a in agg.items()}, fresh=trade and self.stream_fresh(m1_epoch - 60), trade=trade, engine=self,
                          market=self.spec, lag_s=time.time() - m1_epoch)
             out.update(mints_traded=len(agg), eligible=len(mints))
-            for b in [b for b in self.my_books() if getattr(b, "LIVE", False)]:
+            for b in live_books:
                 try:
                     with conn.transaction():                            # a savepoint per book
                         b.on_bars(m1_epoch - 60.0, bars)
@@ -424,38 +437,49 @@ def admit_books(engine: MinuteEngine, live: bool) -> list:
     return new
 
 
+def _live(engine, minute: int, trade: bool):
+    try:
+        return engine.live_phase(float(minute), trade=trade)
+    except Exception:
+        log.exception("%s live minute %s failed", engine.spec.chain, minute); record_event("error", "engine", f"{engine.spec.chain} live minute failed: {minute}")
+        return None
+
+
 def run_ready(engines: list, m1: float) -> list:
     """Every chain's minutes its stream has written up to wall-clock minute ``m1``: older ones whole (catching up: features
-    and the fly's learning only), then each chain's newest -- live money first: every chain's live phase before any
-    chain's paper phase. [(engine, minute, its minute's output or None when it failed)] of the newest minutes."""
-    staged = []
-    for engine in engines:
-        if not engine.my_books() or m1 <= engine.last_minute:
-            continue
-        if (upto := engine.ready_through(m1)) <= engine.last_minute:        # only minutes this chain's stream has written
-            continue
-        for minute in range(int(engine.last_minute) + 60, int(upto), 60):
-            try:
-                engine.run_minute(float(minute), trade=engine.tradeable(minute, m1))
-            except Exception:
-                log.exception("%s minute %s failed", engine.spec.chain, minute); record_event("error", "engine", f"{engine.spec.chain} minute failed: {minute}")
-        staged.append((engine, int(upto)))
-    live = {}
-    for engine, minute in staged:
-        try:
-            live[id(engine)] = engine.live_phase(float(minute), trade=engine.tradeable(minute, m1))
-        except Exception:
-            log.exception("%s live minute %s failed", engine.spec.chain, minute); record_event("error", "engine", f"{engine.spec.chain} live minute failed: {minute}")
-    ran = []
-    for engine, minute in staged:
+    and the fly's learning only), then each chain's newest -- live money first: the chains' live phases at once
+    (``_LIVE_POOL``), every paper phase after them, and before each paper phase the live phase of a minute another
+    chain's stream wrote meanwhile. [(engine, minute, its minute's output or None when it failed)] of the newest minutes."""
+    papers, ran = [], []
+
+    def stage(m1_now: float) -> None:
+        staged = []
+        for engine in engines:
+            if not engine.my_books() or m1_now <= engine.last_minute:
+                continue
+            if (upto := engine.ready_through(m1_now)) <= engine.last_minute:    # only minutes this chain's stream has written
+                continue
+            for minute in range(int(engine.last_minute) + 60, int(upto), 60):
+                try:
+                    engine.run_minute(float(minute), trade=engine.tradeable(minute, m1_now))
+                except Exception:
+                    log.exception("%s minute %s failed", engine.spec.chain, minute); record_event("error", "engine", f"{engine.spec.chain} minute failed: {minute}")
+            engine.last_minute = int(upto)
+            staged.append((engine, int(upto), engine.tradeable(upto, m1_now)))
+        lives = list(_LIVE_POOL.map(lambda s: _live(*s), staged)) if len(staged) > 1 else [_live(*s) for s in staged]
+        papers.extend((engine, minute, lv) for (engine, minute, _), lv in zip(staged, lives))
+
+    stage(m1)
+    while papers:
+        engine, minute, lv = papers.pop(0)
         st = None
-        if id(engine) in live:
+        if lv is not None:
             try:
-                st = engine.paper_phase(*live[id(engine)])
+                st = engine.paper_phase(*lv)
             except Exception:
                 log.exception("%s minute %s failed", engine.spec.chain, minute); record_event("error", "engine", f"{engine.spec.chain} minute failed: {minute}")
-        engine.last_minute = minute
         ran.append((engine, minute, st))
+        stage(math.floor(time.time() / 60) * 60)        # a minute written meanwhile: its live phase before the next paper phase
     return ran
 
 
@@ -509,7 +533,7 @@ def main(stop_event: threading.Event | None = None, live: bool = False) -> None:
                                         for b in engine.my_books()))
             if not ran:                                  # between minutes: bookkeeping that waits for an idle wallet
                 live_first.idle_mirrors()
-            time.sleep(POLL_S)
+            live_first.wait_published(POLL_S)            # back the moment a stream writes a minute
     finally:
         clock.close()
         for b in books:

fly_trader/agent/paper_trading.py

@@ -32,14 +32,22 @@ from ..market.exit_cost import exit_cost_fraction
 
 def plan_minute(ctx, *, book: str, run_id: str, beat_no: int, broker, kind: str, mints: list, infos: list, scores, threshold,
                 table: list | None, horizon_s: float, block: str | None = None, holds=None, strategies=None, allow=None, reasons=None,
-                tables: list | None = None, flat: bool = False) -> dict:
+                tables: list | None = None, flat: bool = False, live_allow=None) -> dict:
     """The minute's beat, exits and entries, decided and quoted but not booked: every entry and blocked pick is already a
     ``decisions`` row (the live mirror buys under the entry's id); ``book_minute`` books the rest.
 
     Optional per-row arguments (the selector's strategy stack, train/strategies.decide): ``threshold`` may be per row,
     ``holds`` (s), ``strategies``, ``tables`` (sizing) and ``allow`` / ``reasons`` (a blocked row is recorded with its reason).
     Left out, the call behaves exactly as the single-strategy engine. ``flat``: every buy the same share of the bankroll
-    (agent/sizing.size_position), the fly's rule (``config.FLY_SIZING``)."""
+    (agent/sizing.size_position), the fly's rule (``config.FLY_SIZING``). ``live_allow``: per row, what the wallet may buy
+    where that differs from this book: a row the book is denied (``allow``) but ``live_allow`` allows is planned for the
+    live mirror alone (``live_only``: its own entry decision, quoted and sized as the book would; never booked here, the
+    book's cash and holdings untouched) -- the fly's learned veto binds its paper book while the selector holds the seat.
+
+    ``rebuy``: each token the book keeps through the minute and has a row of, this minute's verdict on buying it again --
+    its score and line, and where it would (allowed, not blocked; the book's own cash aside) its sizing table and paper's
+    fill price at this minute's price for what the book paid (``ref_price``), else why not (``why``). A live mirror tries
+    a failed entry again only on such a buy, at that price (agent/fly_live.py, rh/live.py)."""
     conn, m1 = ctx.conn, ctx.m1
     beat = conn.execute("INSERT INTO beats (run_id, ts, beat_no, n_slots_active, notes) VALUES (%s,%s,%s,%s,%s) RETURNING id",
                         (run_id, m1, beat_no, len(mints), json.dumps({"minute": m1.isoformat(), "mints_traded": len(ctx.agg), "book": book}))).fetchone()["id"]
@@ -55,6 +63,7 @@ def plan_minute(ctx, *, book: str, run_id: str, beat_no: int, broker, kind: str,
         exits.append((p, held, kw, broker.quote_sell(position=p, **kw)))
     leaving = {int(p["id"]) for p, *_ in exits}
     opens_now = [p for p in opens_before if int(p["id"]) not in leaving]; open_mints = {p["mint"] for p in opens_now}
+    paid = {p["mint"]: float(p["cost_sol"]) for p in opens_now}; rebuy = {}        # a token it keeps: what it paid, this minute's verdict on buying it again
     cash = ledger.paper_cash(conn, book) + sum(q for *_, q in exits); n_enter = 0; picks = []; entries = []; buys = []
     bankroll = cash + sum(float(p["cost_sol"]) for p in opens_now)         # wealth at cost: the sizing base (agent/sizing.py)
     from ..markets import for_book
@@ -65,8 +74,11 @@ def plan_minute(ctx, *, book: str, run_id: str, beat_no: int, broker, kind: str,
                or ("paused" if circuit and circuit["entries_paused"] else None) or ("book halted" if rails.book_halted(conn, book) else None))
     thr_v = np.broadcast_to(np.asarray(threshold, dtype=np.float64), (len(mints),)) if len(mints) else np.array([])
     for k, (m, i, sc) in enumerate(zip(mints, infos, scores)):
-        thr_k = float(thr_v[k])
+        thr_k = float(thr_v[k]); strat_k = None if strategies is None else strategies[k]
         if not np.isfinite(sc) or sc < thr_k:
+            if m in paid:
+                rebuy[m] = {"score": float(sc), "threshold": thr_k,
+                            "why": f"{strat_k + ': ' if strat_k else ''}score {sc:.3f} < {thr_k:.3f}" if np.isfinite(thr_k) else "no strategy picks it"}
             continue
         picks.append((m, float(sc)))
         tab_k = tables[k] if tables is not None else table
@@ -78,8 +90,26 @@ def plan_minute(ctx, *, book: str, run_id: str, beat_no: int, broker, kind: str,
                          (beat, run_id, m1, m, i["pool"], float(sc), size, rail, why if rail == "sizing" else f"{kind} pick not taken",
                           json.dumps({"book": book, "score": float(sc), "threshold": thr_k, "sizing": why,
                                       "strategy": None if strategies is None else strategies[k]})))
+            if m in paid:                # it keeps the token: would this minute buy it again, and paper's fill now for what it paid
+                q = None if blocked or denied else broker.quote_buy(size_sol=paid[m], price=i["price"], res_quote_sol=i["resq"], mcap_sol=i["mcap"], decimals=i["decimals"],
+                                                                       program_label=ctx.cost_label(m, i["program_label"]), pool_fee=ctx.fee(m))
+                rebuy[m] = {"score": float(sc), "threshold": thr_k, **({"table": tab_k, "ref_price": paid[m] / (q.token_delta / 10 ** int(i["decimals"]))} if q is not None and q.ok
+                                                                     else {"why": blocked or (q.reason if q is not None else str(reasons[k]) if reasons is not None else "filtered")})}
+            if denied and live_allow is not None and bool(live_allow[k]) and not blocked and m not in open_mints and size > 0:
+                hold_k = float(holds[k]) if holds is not None else None      # the wallet's buy alone: this book stays as it is
+                did = conn.execute("INSERT INTO decisions (beat_id, run_id, ts, mint, pool, kind, m_hat, size_sol, forced, reason, book_targets, detail) VALUES (%s,%s,%s,%s,%s,%s,%s,%s,false,%s,%s,%s) RETURNING id",
+                                   (beat, run_id, m1, m, i["pool"], f"{kind}_enter", float(sc), size, f"live only ({rail} binds {book}): {strat_k + ': ' if strat_k else ''}score {sc:.3f} ≥ {thr_k:.3f}; {why}", None,
+                                    json.dumps({"book": book, "live_only": True, "score": float(sc), "threshold": thr_k, "size_sol": size, "sizing": why, "resq": i["resq"], "age_h": i["age_h"],
+                                                "price": i["price"], "strategy": strat_k, "hold_s": hold_k}))).fetchone()["id"]
+                q = broker.quote_buy(size_sol=size, price=i["price"], res_quote_sol=i["resq"], mcap_sol=i["mcap"], decimals=i["decimals"],
+                                     program_label=ctx.cost_label(m, i["program_label"]), pool_fee=ctx.fee(m))
+                if q.ok:
+                    entries.append({"mint": m, "decision_id": did, "score": float(sc), "size_sol": size, "info": i, "threshold": thr_k, "table": tab_k, "hold_s": hold_k,
+                                    "strategy": strat_k, "live_only": True, "ref_price": size / (q.token_delta / 10 ** int(i["decimals"]))})
+                else:
+                    conn.execute("UPDATE decisions SET rail = %s, reason = %s WHERE id = %s", ("paper_fill", q.reason, did))
             continue
-        hold_k = float(holds[k]) if holds is not None else None; strat_k = None if strategies is None else strategies[k]
+        hold_k = float(holds[k]) if holds is not None else None
         did = conn.execute("INSERT INTO decisions (beat_id, run_id, ts, mint, pool, kind, m_hat, size_sol, forced, reason, book_targets, detail) VALUES (%s,%s,%s,%s,%s,%s,%s,%s,false,%s,%s,%s) RETURNING id",
                            (beat, run_id, m1, m, i["pool"], f"{kind}_enter", float(sc), size, f"{strat_k + ': ' if strat_k else ''}score {sc:.3f} ≥ {thr_k:.3f}; {why}", [book],
                             json.dumps({"book": book, "score": float(sc), "threshold": thr_k, "size_sol": size, "sizing": why, "resq": i["resq"], "age_h": i["age_h"], "price": i["price"],
@@ -94,7 +124,7 @@ def plan_minute(ctx, *, book: str, run_id: str, beat_no: int, broker, kind: str,
         else:
             conn.execute("UPDATE decisions SET rail = %s, reason = %s WHERE id = %s", ("paper_fill", q.reason, did))
     return {"book": book, "run_id": run_id, "kind": kind, "broker": broker, "beat_id": beat, "exits": exits, "buys": buys, "entries": entries,
-            "entered": n_enter, "picks": picks, "blocked": blocked, "market": market}
+            "entered": n_enter, "picks": picks, "blocked": blocked, "market": market, "rebuy": rebuy}
 
 
 def book_minute(ctx, plan: dict) -> dict:

fly_trader/chain/balances.py

@@ -31,11 +31,14 @@ class Snapshot:
 
 
 def snapshot_balances(rpc, pubkey) -> Snapshot:
-    lamports = int(rpc.get_balance(str(pubkey)))
+    if hasattr(rpc, "wallet_state"):                     # one round trip (chain/rpc.HttpSolanaRpc)
+        lamports, accts = rpc.wallet_state(str(pubkey)); lamports = int(lamports)
+    else:
+        lamports, accts = int(rpc.get_balance(str(pubkey))), rpc.get_token_accounts_by_owner(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)):
+    for acct in accts:
         mint = acct["mint"]
         tokens[mint] = tokens.get(mint, 0) + int(acct["amount"])
         if acct.get("decimals") is not None:

fly_trader/chain/rpc.py

@@ -80,6 +80,21 @@ def _request_summary(method: str, params: list | None) -> dict:
     return {"params": params}
 
 
+def _token_accounts(res, program: str) -> list[dict]:
+    out = []
+    for item in (res or {}).get("value") or []:
+        try:
+            info = item["account"]["data"]["parsed"]["info"]
+            amt = info["tokenAmount"]
+            out.append({"address": item["pubkey"], "mint": info["mint"], "amount": int(amt["amount"]),
+                        "decimals": int(amt["decimals"]), "program": program,
+                        "lamports": int(item["account"].get("lamports") or 0),
+                        "is_native": bool(info.get("isNative")), "state": info.get("state")})
+        except (KeyError, TypeError, ValueError):
+            log.warning("unparsed token account %s", item.get("pubkey") if isinstance(item, dict) else "?")
+    return out
+
+
 class HttpSolanaRpc:
     def __init__(self, url: str | None = None, timeout_s: float = RPC_TIMEOUT_S):
         self._url = url or config.helius_http_url()
@@ -184,18 +199,15 @@ class HttpSolanaRpc:
         for program in TOKEN_PROGRAM_IDS:
             res = self.call("getTokenAccountsByOwner",
                             [str(pubkey), {"programId": program}, {"encoding": "jsonParsed", "commitment": commitment}])
-            for item in (res or {}).get("value") or []:
-                try:
-                    info = item["account"]["data"]["parsed"]["info"]
-                    amt = info["tokenAmount"]
-                    out.append({"address": item["pubkey"], "mint": info["mint"], "amount": int(amt["amount"]),
-                                "decimals": int(amt["decimals"]), "program": program,
-                                "lamports": int(item["account"].get("lamports") or 0),
-                                "is_native": bool(info.get("isNative")), "state": info.get("state")})
-                except (KeyError, TypeError, ValueError):
-                    log.warning("unparsed token account %s", item.get("pubkey") if isinstance(item, dict) else "?")
+            out += _token_accounts(res, program)
         return out
 
+    def wallet_state(self, pubkey, commitment: str = COMMITMENT) -> tuple[int, list[dict]]:
+        """(lamports, ``get_token_accounts_by_owner``) in one round trip (a JSON-RPC batch): a swap's balance snapshot."""
+        res = self.batch([("getBalance", [str(pubkey), {"commitment": commitment}])] +
+                         [("getTokenAccountsByOwner", [str(pubkey), {"programId": p}, {"encoding": "jsonParsed", "commitment": commitment}]) for p in TOKEN_PROGRAM_IDS])
+        return int(res[0]["value"]), [a for r, p in zip(res[1:], TOKEN_PROGRAM_IDS) for a in _token_accounts(r, p)]
+
     def get_signature_statuses(self, sigs: list[str], search_history: bool = False) -> list[dict | None]:
         res = self.call("getSignatureStatuses", [list(sigs), {"searchTransactionHistory": bool(search_history)}])
         value = (res or {}).get("value")

fly_trader/config.py

@@ -17,7 +17,7 @@ load_dotenv(REPO_ROOT / ".env", override=False)
 SECRET_ENV_NAMES = ("HELIUS_API_KEY", "JUPITER_API_KEY", "BOT_PRIVATE_KEY", "KALSHI_API_KEY_ID", "KALSHI_PRIVATE_KEY_PATH",
                     "RELAY_SECRET", "TELEGRAM_BOT_TOKEN", "VAULT_BACKUP_HF_TOKEN", "VAULT_SOLANA_RPC_URL", "SIGNER_RPC_URL",
                     "SOLANA_CHECK_RPC_URL", "HEALTHCHECK_URL", "RH_BOT_PRIVATE_KEY", "RH_RPC_URL_LOGS", "ENVIO_API_TOKEN", "QUICKNODE_API_KEY",
-                    "QUICKNODE_RH_API_KEY", "QUICKNODE_RH_API_URL", "RH_RPC_URL_TX")
+                    "QUICKNODE_RH_API_KEY", "QUICKNODE_RH_API_URL", "RH_RPC_URL_TX", "STREAM_RELAY_TOKEN")
 
 
 def utcnow() -> datetime:
@@ -102,8 +102,10 @@ SLIPPAGE_EXIT_BPS = env_int("SLIPPAGE_EXIT_BPS", 300)
 SLIPPAGE_FORCED_BPS = env_int("SLIPPAGE_FORCED_BPS", 500)
 SLIPPAGE_STEP_BPS = env_int("SLIPPAGE_STEP_BPS", 100)
 MAX_SLIPPAGE_ENTRY_BPS = env_int("MAX_SLIPPAGE_ENTRY_BPS", 300)
+EXEC_THREADS = env_int("EXEC_THREADS", 4)                            # Solana live swaps in flight at once, one per mint (execution/worker.py)
 
 HELIUS_HTTP = "https://mainnet.helius-rpc.com/"
+HELIUS_WSS = "wss://mainnet.helius-rpc.com/"
 JUPITER_SWAP_BASE = "https://api.jup.ag/swap/v2"
 JUPITER_TOKENS_BASE = "https://api.jup.ag/tokens/v2"
 JUPITER_RPS = env_float("JUPITER_RPS", 8.0)
@@ -161,8 +163,9 @@ RESET_ON_START = env_bool("RESET_ON_START", True)  # wipe the paper book and its
 HANDOVER_DAYS = env_int("HANDOVER_DAYS", 14)                        # days of racing first; 0 = as soon as the trades are in
 HANDOVER_MIN_TRADES = env_int("HANDOVER_MIN_TRADES", 30)            # closed paper_fly trades required
 HANDOVER_BEAT_SELECTOR = env_bool("HANDOVER_BEAT_SELECTOR", True)   # and realized P&L at least the paper selector's over the window
-# Trade the wallet as soon as signing is allowed, without waiting for the handover: the fly's teacher-gated decisions (the
-# selector's buys and sizes, less what its learning vetoes) are mirrored onto the wallet whoever holds the seat.
+# Trade the wallet as soon as signing is allowed, without waiting for the handover: the seat holder's decisions are
+# mirrored onto the wallet -- the selector's buys and sizes until the fly wins its race (the fly's learned veto binds only
+# its paper book, which the race measures), the fly's teacher-gated decisions (less what its learning vetoes) after.
 LIVE_WITHOUT_HANDOVER = env_bool("LIVE_WITHOUT_HANDOVER", False)
 
 
@@ -172,6 +175,12 @@ def helius_http_url() -> str:
     return f"{HELIUS_HTTP}?api-key={HELIUS_API_KEY}"
 
 
+def helius_wss_url() -> str:
+    if not HELIUS_API_KEY:
+        raise RuntimeError("HELIUS_API_KEY is not set")
+    return f"{HELIUS_WSS}?api-key={HELIUS_API_KEY}"
+
+
 def summary() -> dict:
     """Non-secret configuration snapshot for ``runs.config``."""
     out = {}
@@ -341,6 +350,12 @@ V3_FACTORY = env_str("V3_FACTORY", "0x1f7d7550b1b028f7571e69a784071f0205fd2efa")
 V3_QUOTER_V2 = env_str("V3_QUOTER_V2", "0x33e885ed0ec9bf04ecfb19341582aadcb4c8a9e7")
 RH_WETH = env_str("RH_WETH", "0x0bd7d308f8e1639fab988df18a8011f41eacad73")      # SwapRouter02.WETH9()
 RH_USDG = env_str("RH_USDG", "0x5fc5360D0400a0Fd4f2af552ADD042D716F1d168")
+# Robinhood Chain's other Uniswap v4 pools (rh/v4_universe.py): a Pons coin's own pools elsewhere and plain v4 memecoins
+RH_V4_ENABLED = env_bool("RH_V4_ENABLED", True)                     # find, check and index them (0: Pons pools only, as before 2026-10-23)
+RH_V4_QUOTES = tuple(a.strip().lower() for a in env_str("RH_V4_QUOTES", RH_USDG).split(",") if a.strip())   # beside ETH and WETH: a plain memecoin's quote
+RH_V4_HOOKS = tuple(a.strip().lower() for a in env_str("RH_V4_HOOKS", "").split(",") if a.strip())          # hooks allowed besides none (fees outside the Swap event)
+RH_V4_CHECKS_PER_SLOT = env_int("RH_V4_CHECKS_PER_SLOT", 1)          # contract checks a minute (each ~10 reads of the public RPC)
+RH_V4_BACKFILL_RPM = env_float("RH_V4_BACKFILL_RPM", 30)             # fly-trader rh-v4-backfill's own HyperSync pace (the console keeps its share)
 KYBER_API = env_str("KYBER_API", "https://aggregator-api.kyberswap.com/robinhood/api/v1")
 KYBER_ROUTER = env_str("KYBER_ROUTER", "0x6131B5fae19EA4f9D964eAc0408E4408b66337b5")  # MetaAggregationRouterV2: the only router a built Kyber tx may call
 KYBER_CLIENT_ID = env_str("KYBER_CLIENT_ID", "fly-trader")
@@ -432,9 +447,22 @@ REPLAY_URL = env_str("REPLAY_URL", "https://replay.pumpapi.io")
 REPLAY_START = env_str("REPLAY_START", "2026-04-18")
 REPLAY_PARALLEL = env_int("REPLAY_PARALLEL", 4)                     # concurrent hour downloads (~2-4 MB/s each)
 REPLAY_ASSEMBLE = env_bool("REPLAY_ASSEMBLE", True)                  # 0: download and parse only (no assembly / corpus_meta / mature rounds)
+# ``fly-trader refetch-archive`` (ingest/replay_pull.refetch_main): hours written before the hour files kept every venue's SOL
+# legs are downloaded again, beside the console, at these settings; it starts no download while the live stream lags
+REFETCH_PARALLEL = env_int("REFETCH_PARALLEL", 2)                    # concurrent hour downloads
+REFETCH_MAX_LAG_S = env_float("REFETCH_MAX_LAG_S", 15.0)             # the live stream's newest event this far behind its status: wait
+REFETCH_SKIP_RECENT_H = env_int("REFETCH_SKIP_RECENT_H", 6)          # the newest hours are the console's replay worker's
 REPLAY_DIR = CORPUS_DIR / "replay"
 CORPUS_PULL_BEFORE = env_str("CORPUS_PULL_BEFORE", REPLAY_START)     # swap-api puller only handles graduations before the replay archive begins
 
 # ---- PumpAPI live stream (free firehose, same events as the replay archive; the selector's parity feed) ----
 PUMPSTREAM_URL = env_str("PUMPSTREAM_URL", "wss://stream.pumpapi.io")
+# pumpapi: PumpAPI's stream alone | relay: PumpAPI's events from our relay near its source (stream_relay/, ingest/relay_feed.py)
+# build the live minutes, PumpAPI's own stream their backup | helius: our own decoder (ingest/helius_feed.py) does, but
+# Helius's websockets delivered ~1 MB/s in all to this machine (2026-10-19), lagging and dropping half the trades when busy
+SOL_FEED = env_str("SOL_FEED", "pumpapi")
+STREAM_RELAY_URL = env_str("STREAM_RELAY_URL")                       # wss://<server>:<port>/stream (stream_relay/README.md)
+STREAM_RELAY_TOKEN = env_str("STREAM_RELAY_TOKEN")                   # the relay's RELAY_TOKEN
+STREAM_RELAY_CA_FILE = env_str("STREAM_RELAY_CA_FILE")               # the CA of a self-signed relay certificate (else the usual roots)
+HELIUS_FEED_COMMITMENT = env_str("HELIUS_FEED_COMMITMENT", "processed")
 PUMP_MINUTES_KEEP_DAYS = env_int("PUMP_MINUTES_KEEP_DAYS", 7)       # older minute rows are archived to Parquet, then removed from the table

fly_trader/db/schema.py

@@ -19,7 +19,7 @@ from .connection import connect, database_name, database_url
 
 log = logging.getLogger(__name__)
 
-SCHEMA_VERSION = 12          # 5: the plastic fly's tables and per-book halts (BASE_DDL); 6: the selector's strategy stack (MIGRATIONS[6]); 7: Kalshi (MIGRATIONS[7]); 8: Kalshi minute extremes
+SCHEMA_VERSION = 13          # 13: a graduation's quote asset (corpus_meta.grad_quote); 5: the plastic fly's tables and per-book halts (BASE_DDL); 6: the selector's strategy stack (MIGRATIONS[6]); 7: Kalshi (MIGRATIONS[7]); 8: Kalshi minute extremes
 _LOCK_KEY = 0x666C795F6D6967  # "fly_mig"
 # Applying the DDL takes ACCESS EXCLUSIVE on the tables it touches (Postgres takes it for ALTER TABLE ... ADD COLUMN IF NOT
 # EXISTS even when the column exists) and holds it to the end of the transaction, while live workers write those tables.
@@ -381,6 +381,9 @@ MIGRATIONS: dict[int, list[str]] = {
     # taker bought YES at (sold NO at 100 − it): a resting bid fills when a taker sells into it (kalshi/decisions.maker_filled)
     12: ["ALTER TABLE kalshi_minutes ADD COLUMN IF NOT EXISTS yes_sold_low real",
          "ALTER TABLE kalshi_minutes ADD COLUMN IF NOT EXISTS yes_bought_high real"],
+    # 13: the quote asset a pump.fun graduation's pool was seeded in (its PumpSwap pool's quote mint): a graduation in USDC,
+    # a stock token or another coin keeps rq0 and dev_sol in those units, so they are not SOL inputs (corpus_meta.sol_select)
+    13: ["ALTER TABLE corpus_meta ADD COLUMN IF NOT EXISTS grad_quote text"],
 }
 
 

fly_trader/execution/broker_live.py

@@ -1,10 +1,11 @@
 """Live execution through Jupiter Swap API v2 with balance-verified fills (plan §9).
 
-Per attempt (one in-flight order per process, guarded by a module lock):
-  assert_signing_allowed() -> pre = snapshot_balances() -> GET /order (taker = bot, excludeRouters=
-  jupiterz) -> assert signatureFeePayer == taker -> orders row (status 'ordered') -> sign only our
-  signer slot -> POST /execute -> orders row updated -> poll getSignatureStatuses every 1 s until
-  confirmed or getBlockHeight() > lastValidBlockHeight (no other timeout) -> post = snapshot ->
+Per attempt (several mints' swaps in flight at once, one per mint: execution/worker.py):
+  assert_signing_allowed() -> pre = snapshot_balances() beside GET /order (taker = bot, excludeRouters=
+  jupiterz) and the signing, taken before anything is sent -> assert signatureFeePayer == taker -> orders row (status
+  'ordered') -> sign only our signer slot -> POST /execute -> orders row updated -> poll getSignatureStatuses every
+  ``CONFIRM_POLL_S`` until confirmed or getBlockHeight() > lastValidBlockHeight (no other timeout) -> post = snapshot
+  beside the swap's own transaction, whose deltas are the fill (another swap may land between the two snapshots) ->
   fill iff the input balance decreased AND the output balance increased (a confirmed sell whose token
   balance fell is a fill even when the SOL delta is <= 0: dust proceeds below fees) -> fills row.
 
@@ -29,6 +30,7 @@ import logging
 import re
 import threading
 import time
+from concurrent.futures import ThreadPoolExecutor
 from dataclasses import dataclass
 
 from psycopg.types.json import Jsonb
@@ -49,11 +51,14 @@ from . import ledger
 
 log = logging.getLogger(__name__)
 
-_INFLIGHT = threading.Lock()  # one in-flight order at a time (plan §9)
+_INFLIGHT = threading.Lock()  # one token-account close at a time (``close_empty_atas``)
 _UNSETTLED: dict[str, dict] = {}   # token-account closes sent whose wait ended before they landed or expired (``settle_closes``)
 _UNSETTLED_LOCK = threading.Lock()
+_IO = ThreadPoolExecutor(max_workers=8, thread_name_prefix="runner-exec-io")   # a swap's reads beside its order, signing and confirmation
+_SWAPS = {"active": 0, "started": 0}               # swaps in flight now / ever: whether another swap's balances moved between a swap's snapshots
+_SWAPS_LOCK = threading.Lock()
 
-CONFIRM_POLL_S = 1.0
+CONFIRM_POLL_S = 0.4          # one slot
 BLOCKHASH_VALIDITY_BLOCKS = 150  # fallback horizon when /order carries no lastValidBlockHeight
 CLOSE_ATA_BATCH = 10
 BASE_FEE_LAMPORTS = 5_000       # one signature, no priority fee: what the signer's close transaction pays
@@ -178,29 +183,35 @@ class LiveBroker:
             input_mint, output_mint = config.WSOL_MINT, mint
         else:
             input_mint, output_mint = mint, config.WSOL_MINT
-        with _INFLIGHT:
-            slip = int(slippage_bps)
-            attempt = 0
-            while True:
-                attempt += 1
+        slip = int(slippage_bps)
+        attempt = 0
+        while True:
+            attempt += 1
+            with _SWAPS_LOCK:
+                seen = (_SWAPS["active"], _SWAPS["started"]); _SWAPS["active"] += 1; _SWAPS["started"] += 1
+            try:
                 result, retryable = self._attempt(
                     conn, decision_id=decision_id, book=book, side=side, mint=mint, input_mint=input_mint,
                     output_mint=output_mint, amount_in=amount_in, slippage_bps=slip, attempt=attempt,
-                    ref_price=ref_price if side == "buy" else None, decimals=decimals)
-                result.attempts = attempt
-                if result.ok or not retryable or step_bps <= 0 or slip + step_bps > max_slippage_bps:
-                    if retryable and not result.ok:
-                        log.warning("order %s not retried: slippage ladder exhausted at %d bps", result.order_id, slip)
-                    return result
-                slip += int(step_bps)
-                log.warning("retrying %s %s after %s (code %s) with slippage %d bps",
-                            side, mint, result.status, result.code, slip)
+                    ref_price=ref_price if side == "buy" else None, decimals=decimals, seen=seen)
+            finally:
+                with _SWAPS_LOCK:
+                    _SWAPS["active"] -= 1
+            result.attempts = attempt
+            if result.ok or not retryable or step_bps <= 0 or slip + step_bps > max_slippage_bps:
+                if retryable and not result.ok:
+                    log.warning("order %s not retried: slippage ladder exhausted at %d bps", result.order_id, slip)
+                return result
+            slip += int(step_bps)
+            log.warning("retrying %s %s after %s (code %s) with slippage %d bps",
+                        side, mint, result.status, result.code, slip)
 
     # ---- one attempt ----
     def _attempt(self, conn, *, decision_id, book, side, mint, input_mint, output_mint, amount_in,
-                 slippage_bps, attempt, ref_price=None, decimals=None) -> tuple[FillResult, bool]:
+                 slippage_bps, attempt, ref_price=None, decimals=None, seen=(0, 0)) -> tuple[FillResult, bool]:
+        """``seen``: (swaps in flight, swaps started) when this one began (``swap``)."""
         taker = self.pubkey
-        pre = snapshot_balances(self.rpc, taker)
+        pre_f = _IO.submit(snapshot_balances, self.rpc, taker)          # the balances before, read beside the order and the signing
         request = {"inputMint": input_mint, "outputMint": output_mint, "amount": str(amount_in), "taker": taker,
                    "slippageBps": slippage_bps, "excludeRouters": EXCLUDE_ROUTERS}
         base = dict(decision_id=decision_id, book=book, attempt=attempt, side=side, input_mint=input_mint,
@@ -258,6 +269,10 @@ class LiveBroker:
         except SignerUnavailable as e:
             return fail("sign_error", scrub(str(e)), None, order_id=order_id)
         signed_b64, tx_sig = signed["tx"], signed["signature"]
+        try:
+            pre = pre_f.result()                         # taken before anything is sent
+        except Exception as e:
+            return fail("unsent", f"the balances before could not be read: {type(e).__name__}: {scrub(str(e))}", None, order_id=order_id)
 
         # 3. execute
         exec_req = {"requestId": order.get("requestId"), "lastValidBlockHeight": lvbh, "signedTransaction": signed_b64}
@@ -280,20 +295,30 @@ class LiveBroker:
             self._update_order(conn, order_id, execute_request=exec_req, execute_response=ex, signature=signature,
                                status="executed", error_code=code, error=error, latency_ms=ex.get("_latency_ms"))
 
-        # 4. confirm (or expire), 5. verify by balance deltas — retried: a transport error here must not leave a landed swap unrecorded
-        chain_status = st = post = None; last_exc = None
+        # 4. confirm (or expire), 5. verify: the balances after, beside the swap's own transaction — retried: a transport
+        # error here must not leave a landed swap unrecorded
+        chain_status = st = post = tx = None; last_exc = None
         for k in range(4):
             try:
                 if chain_status is None:
                     chain_status, st = await_confirmation(self.rpc, signature, lvbh)
                     self._update_order(conn, order_id, status=chain_status)
-                post = snapshot_balances(self.rpc, taker); break
+                post_f = _IO.submit(snapshot_balances, self.rpc, taker)
+                tx_f = _IO.submit(self._landed, signature) if chain_status == "confirmed" else None
+                post = post_f.result(); tx = tx_f.result() if tx_f is not None else None; break
             except Exception as e:                       # RPC transport / RPC errors
                 last_exc = e; log.warning("confirm/verify attempt %d for %s failed: %s", k + 1, signature, scrub(str(e)))
                 time.sleep(2.0 * (k + 1))
-        if post is None:
-            fill_id = self._insert_fill(conn, order_id, book, signature, None, mint, side, 0, 0, None, None, order.get("platformFee"), "unknown", pre, pre)
-            record_event("error", "broker_live", "fill unknown: could not confirm or verify after retries; entries paused until reconciled (verify-fills)",
+        # another swap, a vault deposit or claim, or a token-account close left unsettled may move the wallet between the
+        # two snapshots: the fill is the swap's own transaction's deltas, so SOL landing meanwhile never becomes part of a
+        # trade's cost or proceeds; with other swaps in flight the snapshots cannot stand in for an unreadable transaction
+        exact = tx_deltas(tx, str(taker), mint) if tx else None
+        with _SWAPS_LOCK:
+            moved = seen[0] > 0 or _SWAPS["started"] - seen[1] > 1
+        if post is None or (chain_status == "confirmed" and exact is None and moved):
+            why = "could not confirm or verify after retries" if post is None else "its transaction could not be read and other swaps moved the wallet meanwhile"
+            fill_id = self._insert_fill(conn, order_id, book, signature, None, mint, side, 0, 0, None, None, order.get("platformFee"), "unknown", pre, post or pre)
+            record_event("error", "broker_live", f"fill unknown: {why}; entries paused until reconciled (verify-fills)",
                          {"order_id": order_id, "signature": signature, "side": side, "mint": mint, "error": scrub(str(last_exc))[:200]})
             try:                                            # a landed but unrecorded swap must not be bought again or leave a stale position
                 with transaction() as c2:
@@ -301,23 +326,15 @@ class LiveBroker:
                     c2.execute("INSERT INTO circuit_events (kind, detail) VALUES ('unknown_fill_pause', %s)", (Jsonb({"order_id": order_id, "signature": signature, "mint": mint, "side": side}),))
             except Exception:
                 log.exception("could not pause entries after an unknown fill")
-            raise RuntimeError(f"confirm/verify failed for {signature}: {type(last_exc).__name__}") from last_exc
+            raise RuntimeError(f"confirm/verify failed for {signature}: {why}") from last_exc
         delta = compute_delta(pre, post)
         lam = int(delta["lamports_delta"])
         tok = int(delta["token_deltas"].get(mint, 0))
-        if (config.VAULT_ENABLED or _UNSETTLED) and chain_status == "confirmed":
-            # the vault fly's wallet also receives deposits and pays claims, and a token-account close left unsettled may
-            # land at any time: take the swap's own deltas from the transaction, so SOL landing between the two snapshots
-            # never becomes part of a trade's cost or proceeds
-            try:
-                exact = tx_deltas(self.rpc.get_transaction(signature), str(taker), mint)
-            except Exception as e:
-                exact = None; log.warning("getTransaction for exact fill deltas failed: %s", type(e).__name__)
-            if exact is not None:
-                if exact != (lam, tok):
-                    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
+        if exact is not None and chain_status == "confirmed":
+            if exact != (lam, tok):
+                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))
@@ -338,9 +355,9 @@ class LiveBroker:
                      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, dep), False
         if jup_status == "Success" or chain_status == "confirmed":
-            tx_info = None
+            tx_info = tx
             try:
-                tx_info = self.rpc.get_transaction(signature)
+                tx_info = tx_info or self.rpc.get_transaction(signature)
             except Exception as e:
                 log.warning("getTransaction failed for %s: %s", signature, type(e).__name__)
             meta = (tx_info or {}).get("meta") or {}
@@ -359,6 +376,18 @@ class LiveBroker:
         return FillResult(False, order_id, None, signature, chain_status, code, error, tok, lam, None, attempt), retryable
 
     # ---- helpers ----
+    def _landed(self, signature: str) -> dict | None:
+        """The confirmed swap's transaction; None when unreadable (a node may not serve it the moment it confirms)."""
+        for k in range(3):
+            try:
+                tx = self.rpc.get_transaction(signature)
+            except Exception as e:
+                tx = None; log.warning("getTransaction for the fill of %s failed: %s", signature[:12], type(e).__name__)
+            if tx:
+                return tx
+            time.sleep(0.3 * (k + 1))
+        return None
+
     def _decimals(self, conn, mint: str, pre: Snapshot, post: Snapshot) -> int | None:
         d = post.decimals.get(mint, pre.decimals.get(mint))
         if d is not None:
@@ -455,8 +484,8 @@ def close_empty_atas(rpc=None, signer=None, url: str | None = None, batch: int =
                      until=None) -> dict:
     """Close every zero-balance token account owned by the bot (rent back to the wallet) and book what each returned
     (``_book_close``). The signer builds and signs the CloseAccount transactions (it re-checks that each account is ours
-    and empty); each is recorded as wallet_events(kind='ata_closed'). A transaction holds the in-flight lock from its
-    signing to its outcome, so no swap's balance snapshots straddle it. ``until``: checked while a close is awaited and
+    and empty); each is recorded as wallet_events(kind='ata_closed'). A transaction holds the close lock from its
+    signing to its outcome; a swap meanwhile takes its fill from its own transaction. ``until``: checked while a close is awaited and
     before each batch; its True starts no other and leaves the one in flight unsettled (``settle_closes`` books it; until
     then swaps take their deltas from their own transactions)."""
     assert_signing_allowed()

fly_trader/execution/worker.py

@@ -1,13 +1,14 @@
 """Execution queue for the live book: the caller never blocks on Jupiter.
 
-The caller enqueues ExecRequest objects; one background thread executes them sequentially through
-LiveBroker (one in-flight order at a time, balance-verified); results are drained by the caller, which
+The caller enqueues ExecRequest objects; ``threads`` background threads (config.EXEC_THREADS) execute them through
+LiveBroker, several mints' swaps in flight at once and each mint's one at a time, in order (each fill is read from its
+own transaction, execution/broker_live.py); results are drained by the caller, which
 opens/closes positions accordingly. A mint with a request queued or in flight takes no other, except a buy queued
 behind a lone sale of it (its paper book sold and bought the token again in one minute): the sale runs first, and the
-buy is refused as held if the sale left the position open. ``busy`` is held from a swap to its booking, so whoever reads
-the wallet and the books under it sees them agree. A sale that leaves the live book without its mint marks the mint's
+buy is refused as held if the sale left the position open. ``busy`` is held (shared) from each swap to its booking, so
+whoever reads the wallet and the books under it alone sees them agree. A sale that leaves the live book without its mint marks the mint's
 token account ``emptied``: the mirror closes it mid-minute with nothing queued (agent/fly_live.close_accounts), never in
-front of an order, and books the rent it returns. ``stop`` lets the request in flight finish (bounded) and drops the
+front of an order, and books the rent it returns. ``stop`` lets the requests in flight finish (bounded) and drops the
 queued ones: exits are retried next minute, entries by the mirror (agent/fly_live.py).
 """
 from __future__ import annotations
@@ -15,7 +16,10 @@ from __future__ import annotations
 import logging
 import queue
 import threading
+import time
 import traceback
+from collections import deque
+from contextlib import contextmanager
 from dataclasses import dataclass, field
 from datetime import datetime, timezone
 
@@ -64,29 +68,76 @@ class ExecResult:
     closed: bool = False          # a sale that closed its position (or swept a written-off one)
 
 
+class SharedLock:
+    """``busy``: every swap in flight holds it shared, any number at once (``shared``); a wealth mark or a token-account
+    close holds it alone (``acquire``/``release``, as a Lock), so none reads the wallet and the books while a swap is
+    between its fill and its booking. A swap waits only behind one holding it alone, never behind one waiting (live
+    money first)."""
+
+    def __init__(self):
+        self._cv = threading.Condition(); self._shared = 0; self._alone = False
+
+    def acquire(self, blocking: bool = True, timeout: float = -1) -> bool:
+        with self._cv:
+            free = lambda: not self._shared and not self._alone
+            if not (free() if not blocking else self._cv.wait_for(free, None if timeout is None or timeout < 0 else timeout)):
+                return False
+            self._alone = True
+            return True
+
+    def release(self) -> None:
+        with self._cv:
+            self._alone = False; self._cv.notify_all()
+
+    def __enter__(self):
+        self.acquire()
+        return self
+
+    def __exit__(self, *exc) -> None:
+        self.release()
+
+    @contextmanager
+    def shared(self):
+        with self._cv:
+            self._cv.wait_for(lambda: not self._alone)
+            self._shared += 1
+        try:
+            yield
+        finally:
+            with self._cv:
+                self._shared -= 1; self._cv.notify_all()
+
+
 class ExecutionWorker:
-    def __init__(self, broker):
+    def __init__(self, broker, threads: int | None = None):
         self.broker = broker
-        self.q: queue.Queue[ExecRequest] = queue.Queue()
         self.results: queue.Queue[ExecResult] = queue.Queue()
         self.inflight: dict[str, list[str]] = {}       # mint -> sides queued or in flight, in order
         self.lock = threading.Lock()
-        self.busy = threading.Lock()                    # held from a request's swap to its booking
-        self.thread = threading.Thread(target=self._loop, name="runner-exec", daemon=True)   # routed to the runner's log
+        self.cv = threading.Condition(self.lock)
+        self.waiting: dict[str, deque] = {}            # mint -> its requests not started yet, in order
+        self.ready: deque[str] = deque()               # mints whose next request may start (none of theirs in flight)
+        self.busy = SharedLock()                       # held (shared) from each swap to its booking
         self.stop_flag = False
         self.on_done = None                            # called with each result once booked (the mirror's live stats: agent/fly_live.py)
         self.emptied: set[str] = set()                 # mints whose sale left their token account empty: closed by the mirror, mid-minute
-        self.thread.start()
+        n = max(1, int(threads if threads is not None else config.EXEC_THREADS))
+        self.threads = [threading.Thread(target=self._loop, name="runner-exec" + (f"-{i}" if i else ""), daemon=True) for i in range(n)]   # routed to the runner's log
+        self.thread = self.threads[0]
+        for t in self.threads:
+            t.start()
 
     def submit(self, req: ExecRequest) -> bool:
         """Queue ``req``; False when its mint already has a request queued or in flight (a buy may queue behind a lone
-        sale of it) or the worker is stopping."""
+        sale of it) or the worker is stopping. A mint with nothing queued or in flight starts at once on a free thread."""
         with self.lock:
             sides = self.inflight.get(req.mint)
             if self.stop_flag or (sides and not (req.side == "buy" and sides == ["sell"])):
                 return False
             self.inflight.setdefault(req.mint, []).append(req.side)
-        self.q.put(req)
+            self.waiting.setdefault(req.mint, deque()).append(req)
+            if not sides:
+                self.ready.append(req.mint); self.cv.notify()
         return True
 
     def pending(self) -> set[str]:
@@ -108,37 +159,44 @@ class ExecutionWorker:
         return out
 
     def _release(self, req: ExecRequest) -> None:
+        """``req`` is done (or dropped): its mint's next request, if one is queued, may start."""
         with self.lock:
             sides = self.inflight.get(req.mint)
             if sides and req.side in sides:
                 sides.remove(req.side)
             if not sides:
                 self.inflight.pop(req.mint, None)
+            if self.waiting.get(req.mint):
+                if not self.stop_flag:
+                    self.ready.append(req.mint); self.cv.notify()
+            else:
+                self.waiting.pop(req.mint, None)
 
     def stop(self, timeout: float = STOP_JOIN_S) -> None:
-        """Let the request in flight finish — a process killed mid-swap can leave a landed swap unbooked — drop the
-        queued ones, and wait for the thread (at most ``timeout``)."""
-        self.stop_flag = True
-        while True:
-            try:
-                self._release(self.q.get_nowait())
-            except queue.Empty:
-                break
-        if self.thread.is_alive() and self.thread is not threading.current_thread():
-            self.thread.join(timeout)
-            if self.thread.is_alive():
-                log.error("execution worker: the request in flight did not finish within %.0f s of the stop", timeout)
+        """Let the requests in flight finish — a process killed mid-swap can leave a landed swap unbooked — drop the
+        queued ones, and wait for the threads (at most ``timeout`` in all)."""
+        with self.lock:
+            self.stop_flag = True
+            dropped = [r for q in self.waiting.values() for r in q]
+            self.waiting.clear(); self.ready.clear(); self.cv.notify_all()
+        for r in dropped:
+            self._release(r)
+        deadline = time.monotonic() + timeout
+        others = [t for t in self.threads if t is not threading.current_thread()]
+        for t in others:
+            t.join(max(0.0, deadline - time.monotonic()))
+        if any(t.is_alive() for t in others):
+            log.error("execution worker: a request in flight did not finish within %.0f s of the stop", timeout)
 
     def _loop(self) -> None:
-        while not self.stop_flag:
-            try:
-                req = self.q.get(timeout=1.0)
-            except queue.Empty:
-                continue
-            if self.stop_flag:                          # stopping: a queued request is dropped, never started
-                self._release(req)
-                break
-            with self.busy:
+        while True:
+            with self.lock:
+                while not self.stop_flag and not self.ready:
+                    self.cv.wait(1.0)
+                if self.stop_flag:                      # stopping: a queued request is dropped, never started
+                    return
+                mint = self.ready.popleft(); req = self.waiting[mint].popleft()
+            with self.busy.shared():
                 res = self._execute(req)
                 if res.ok and res.closed:
                     self._emptied(req)

fly_trader/ingest/helius_feed.py

@@ -0,0 +1,428 @@
+"""Our own Solana feed for the live minutes: pump.fun and PumpSwap events from Helius's standard websockets, decoded into
+the event dicts PumpAPI's stream sends, so ingest/pumpstream.Aggregator builds the same minutes training reads from
+PumpAPI's archive (checked field by field against it on 2026-10-19).
+
+- Transport: ``logsSubscribe`` (processed) on each program, one connection each. A transaction's logs carry its events
+  as ``Program data:`` lines, but Solana cuts logs at 10 KB: every migration and the wash bots' 4-swap transactions lose
+  events that way. A cut-off transaction is fetched whole (``getTransaction``, confirmed) and decoded from its inner
+  instructions (the events' self-CPI copies) instead; its logs are never used.
+- PumpSwap trades name their pool, not their mints: ``Pools`` maps pool -> (base, quote) mint from the stream's recent
+  minutes, the pool creations seen, and the pool accounts themselves (``getMultipleAccounts``) for a pool first seen.
+- PumpAPI's definitions (archive): a trade's SOL is the pool-side quote amount; ``quoteInPool`` and the price are the
+  pool's state after the transaction's last swap in that pool, the price counting the pool's virtual quote reserve;
+  the trader is the event's user; the timestamp is ``TS_OFFSET_S`` after the block's second (PumpAPI stamps on receipt);
+  a create's dev buy is its creator's buys in the same transaction and a mayhem-mode coin's supply counts the agent's
+  billion; a migration's ``quoteInPool`` is the pool's real quote after its boost (``InitBoostEvent``).
+- ``pending``: per minute, transactions still being fetched or waiting for their pool: the minute's flush waits for them
+  (``Aggregator.flush_bound``), at most ``pumpstream.HOLD_MAX_S``.
+"""
+from __future__ import annotations
+
+import asyncio
+import base64
+import hashlib
+import json
+import logging
+import ssl
+import time
+from collections import Counter
+
+import base58
+import certifi
+import orjson
+import websockets
+
+from .. import config
+
+log = logging.getLogger(__name__)
+PUMP = "6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P"          # pump.fun bonding curves
+AMM = "pAMMBay6oceH9fJKBRHGP5D4bD4sWpmSwMn52FMfXEA"           # PumpSwap
+WSOL = "So11111111111111111111111111111111111111112"
+TS_OFFSET_S = 0.9            # PumpAPI's stamp after the block's second (archive ts - blockTime: p05 0.79, p50 0.90, p95 1.12 s)
+EVENT_IX_TAG = bytes.fromhex("e445a52e51cb9a1d")              # Anchor's self-CPI event instruction
+EVENTS = ("BuyEvent", "SellEvent", "CreatePoolEvent", "InitBoostEvent", "TradeEvent", "CreateEvent", "CompletePumpAmmMigrationEvent")
+DISC = {hashlib.sha256(f"event:{n}".encode()).digest()[:8]: n for n in EVENTS}
+BACKFILL_RETRY_S, BACKFILL_GIVE_UP_S, BACKFILL_BATCH = 0.3, 8.0, 25
+RESOLVE_BATCH, STALE_S = 100, 5.0
+
+
+def _u64(b: bytes, o: int) -> int:
+    return int.from_bytes(b[o:o + 8], "little")
+
+
+def _pk(b: bytes, o: int) -> str:
+    return base58.b58encode(b[o:o + 32]).decode()
+
+
+def _str(b: bytes, o: int) -> tuple[str, int]:
+    n = int.from_bytes(b[o:o + 4], "little")
+    return b[o + 4:o + 4 + n].decode("utf-8", "replace").replace("\x00", ""), o + 4 + n
+
+
+def log_events(logs: list[str]) -> list[tuple[str, bytes]]:
+    """(event name, payload) of every known event in a transaction's logs, in order."""
+    out = []
+    for line in logs or ():
+        if line.startswith("Program data: "):
+            try:
+                b = base64.b64decode(line[14:])
+            except ValueError:
+                continue
+            n = DISC.get(b[:8])
+            if n:
+                out.append((n, b[8:]))
+    return out
+
+
+def cpi_events(tx: dict) -> list[tuple[str, bytes]]:
+    """The same from a whole transaction (getTransaction, json): the events' self-CPI copies in its inner instructions,
+    which the 10 KB log limit never cuts."""
+    meta = tx.get("meta") or {}
+    la = meta.get("loadedAddresses") or {}
+    keys = list(tx["transaction"]["message"]["accountKeys"]) + list(la.get("writable") or []) + list(la.get("readonly") or [])
+    out = []
+    for grp in sorted(meta.get("innerInstructions") or [], key=lambda g: g.get("index", 0)):
+        for ix in grp.get("instructions") or []:
+            if keys[ix["programIdIndex"]] not in (PUMP, AMM):
+                continue
+            d = base58.b58decode(ix["data"])
+            if d[:8] == EVENT_IX_TAG:
+                n = DISC.get(d[8:16])
+                if n:
+                    out.append((n, d[16:]))
+    return out
+
+
+def amm_trade(name: str, p: bytes) -> dict:
+    """A PumpSwap Buy/SellEvent: the fields PumpAPI's trade needs (raw units). The virtual quote reserve sits after the
+    buy's variable-length instruction name; a sale has none."""
+    if name == "SellEvent":
+        vq_at = 384
+    else:
+        vq_at = 397 + int.from_bytes(p[393:397], "little") + 32
+    vq = int.from_bytes(p[vq_at:vq_at + 16], "little", signed=True) if len(p) >= vq_at + 16 else 0
+    return {"side": "buy" if name == "BuyEvent" else "sell", "ts": _u64(p, 0), "base": _u64(p, 8), "pbr": _u64(p, 40), "pqr": _u64(p, 48),
+            "q": _u64(p, 56), "fee_bps": _u64(p, 64) + _u64(p, 80) + _u64(p, 336), "pool": _pk(p, 112), "user": _pk(p, 144), "vq": max(vq, 0)}
+
+
+def curve_trade(p: bytes) -> dict:
+    return {"mint": _pk(p, 0), "sol": _u64(p, 32), "token": _u64(p, 40), "buy": bool(p[48]), "user": _pk(p, 49), "ts": _u64(p, 81)}
+
+
+def create(p: bytes) -> dict:
+    name, o = _str(p, 0); symbol, o = _str(p, o); uri, o = _str(p, o)
+    return {"name": name, "symbol": symbol, "uri": uri, "mint": _pk(p, o), "user": _pk(p, o + 64), "creator": _pk(p, o + 96),
+            "ts": _u64(p, o + 128), "supply": _u64(p, o + 160), "mayhem": bool(p[o + 200]) if len(p) > o + 200 else False}
+
+
+def create_pool(p: bytes) -> dict:
+    return {"ts": _u64(p, 0), "creator": _pk(p, 10), "base": _pk(p, 42), "quote": _pk(p, 74), "pool_quote": _u64(p, 132), "pool": _pk(p, 165)}
+
+
+def migration(p: bytes) -> dict:
+    return {"user": _pk(p, 0), "mint": _pk(p, 32), "sol": _u64(p, 72), "ts": _u64(p, 120), "pool": _pk(p, 128)}
+
+
+def init_boost(p: bytes) -> dict:
+    return {"ts": _u64(p, 0), "mint": _pk(p, 8), "pool": _pk(p, 72), "real_quote_after": _u64(p, 120)}
+
+
+def _ms(ts: int) -> float:
+    return (ts + TS_OFFSET_S) * 1000.0
+
+
+def build(sig: str, slot: int, evs: list[tuple[str, bytes]], pools: dict, payer: str | None = None, pumpfun=None) -> tuple[list[dict], set]:
+    """PumpAPI-shaped events of one transaction, and the PumpSwap pools whose mints are not known yet (then nothing is
+    built: the caller resolves them and builds again)."""
+    trades, curve, creates, cpools = [], [], [], []
+    mig = boost = None
+    for n, p in evs:
+        try:
+            if n in ("BuyEvent", "SellEvent"):
+                trades.append(amm_trade(n, p))
+            elif n == "TradeEvent":
+                curve.append(curve_trade(p))
+            elif n == "CreateEvent":
+                creates.append(create(p))
+            elif n == "CreatePoolEvent":
+                cpools.append(create_pool(p))
+            elif n == "CompletePumpAmmMigrationEvent":
+                mig = migration(p)
+            elif n == "InitBoostEvent":
+                boost = init_boost(p)
+        except (IndexError, ValueError):
+            log.warning("undecodable %s in %s", n, sig[:12])
+    for c in cpools:                                     # a pool created here names its mints for the trades after it
+        pools[c["pool"]] = (c["base"], c["quote"])
+    unknown = {t["pool"] for t in trades if t["pool"] not in pools}
+    if unknown:
+        return [], unknown
+    out: list[dict] = []
+    for c in creates:                                    # the create first: the curve state its dev buy lands in
+        dev = [t for t in curve if t["mint"] == c["mint"] and t["buy"] and t["user"] in (c["user"], c["creator"])]
+        out.append({"action": "create", "pool": "pump", "mint": c["mint"], "timestamp": _ms(c["ts"]), "txSigner": c["user"],
+                    "quoteAmount": sum(t["sol"] for t in dev) / 1e9, "initialBuy": sum(t["token"] for t in dev) / 1e6,
+                    "supply": c["supply"] / 1e6 * (2 if c["mayhem"] else 1), "mayhemMode": c["mayhem"], "name": c["name"], "symbol": c["symbol"],
+                    "uri": c["uri"], "signature": sig, "block": slot})
+    by_mint: dict[str, list] = {}
+    for t in curve:
+        by_mint.setdefault(t["mint"], []).append(t)
+    for mint, legs in by_mint.items():
+        out.append({"action": "buy" if legs[0]["buy"] else "sell", "pool": "pump", "mint": mint, "timestamp": _ms(legs[0]["ts"]), "block": slot,
+                    "txSigner": legs[0]["user"], "tokenAmount": legs[0]["token"] / 1e6, "signature": sig,
+                    "breakdown": [{"action": "buy" if t["buy"] else "sell", "trader": t["user"], "tokenAmount": t["token"] / 1e6} for t in legs]})
+    by_pool: dict[str, list] = {}
+    for t in trades:
+        by_pool.setdefault(t["pool"], []).append(t)
+    for pool, legs in by_pool.items():
+        base, quote = pools[pool]
+        last = legs[-1]; sgn = 1 if last["side"] == "buy" else -1
+        post_q, post_b = last["pqr"] + sgn * last["q"], last["pbr"] - sgn * last["base"]
+        dec = 6 if (pumpfun(base) if pumpfun is not None else base.endswith("pump")) else None   # only pump.fun coins (6 decimals) are priced: the minutes keep no other
+        out.append({"action": legs[0]["side"], "pool": "pump-amm", "mint": base, "quoteMint": quote, "poolId": pool, "timestamp": _ms(legs[0]["ts"]),
+                    "price": ((post_q + last["vq"]) / 1e9) / (post_b / 10 ** dec) if dec is not None and post_b > 0 else None,
+                    "quoteInPool": post_q / 1e9, "quoteAmount": legs[0]["q"] / 1e9, "txSigner": legs[0]["user"], "poolFeeRate": last["fee_bps"] / 1e4,
+                    "signature": sig, "block": slot,
+                    "breakdown": [{"action": t["side"], "trader": t["user"], "quoteAmount": t["q"] / 1e9} for t in legs]})
+    for c in cpools:
+        if mig is not None and mig["pool"] == c["pool"]:
+            out.append({"action": "migrate", "pool": "pump-amm", "mint": mig["mint"], "timestamp": _ms(mig["ts"]), "signature": sig, "poolId": c["pool"],
+                        "txSigner": payer or mig["user"], "block": slot,
+                        "quoteInPool": (boost["real_quote_after"] if boost and boost["pool"] == c["pool"] else c["pool_quote"]) / 1e9})
+        else:                                            # created directly, not by a pump.fun migration: the owner can pull it
+            out.append({"action": "createPool", "pool": "pump-amm", "poolId": c["pool"], "mint": c["base"], "poolCreatedBy": c["creator"],
+                        "timestamp": _ms(c["ts"]), "signature": sig})
+    return out, set()
+
+
+def minute_of(evs: list[tuple[str, bytes]]) -> int | None:
+    """The minute (start, epoch s) a transaction's events are stamped in, from the first event carrying a timestamp."""
+    for n, p in evs:
+        try:
+            ts = {"BuyEvent": 0, "SellEvent": 0, "CreatePoolEvent": 0, "InitBoostEvent": 0}.get(n)
+            t = _u64(p, ts) if ts is not None else curve_trade(p)["ts"] if n == "TradeEvent" else None
+        except (IndexError, ValueError):
+            t = None
+        if t:
+            return int((t + TS_OFFSET_S) // 60) * 60
+    return None
+
+
+class Pools:
+    """pool -> (base mint, quote mint) of PumpSwap pools: seeded from the stream's recent minutes, learned from pool
+    creations, else read from the pool account (``base_mint`` at byte 43, ``quote_mint`` at 75)."""
+
+    def __init__(self):
+        self.map: dict[str, tuple[str, str]] = {}
+
+    def seed(self) -> int:
+        from ..db.connection import transaction
+        try:
+            with transaction() as conn:
+                rows = conn.execute("SELECT DISTINCT ON (pool_id) pool_id, mint FROM pump_minutes WHERE pool_id IS NOT NULL AND ts > now() - interval '3 days'").fetchall()
+        except Exception:
+            log.exception("pool map seed failed; pools are read as they come")
+            return 0
+        for r in rows:
+            self.map.setdefault(r["pool_id"], (r["mint"], WSOL))
+        return len(rows)
+
+    def resolve(self, rpc, pools: list[str]) -> int:
+        """Read unknown pool accounts (``rpc``: chain/rpc.HttpSolanaRpc); a pool that is not a PumpSwap pool maps to
+        ('', '') so its trades are dropped."""
+        n = 0
+        for i in range(0, len(pools), RESOLVE_BATCH):
+            chunk = pools[i:i + RESOLVE_BATCH]
+            v = (rpc.call("getMultipleAccounts", [chunk, {"encoding": "base64", "commitment": "processed"}]) or {}).get("value") or []
+            for pool, acc in zip(chunk, v):
+                if acc and acc.get("owner") == AMM:
+                    d = base64.b64decode(acc["data"][0])
+                    self.map[pool] = (_pk(d, 43), _pk(d, 75)) if len(d) >= 107 else ("", "")
+                else:
+                    self.map[pool] = ("", "")
+                n += 1
+        return n
+
+
+class HeliusFeed:
+    """Both programs' logs on their own connections; decoded transactions go to ``emit(events, source='helius')``, each
+    once (a migration comes on both). ``wm``: the newest PumpSwap event stamp (epoch s) — the minutes' clock while the
+    feed is up (``up``), ``grace_s`` back."""
+    source = "helius"
+    grace_s = 0.5                # its stamps are its blocks' seconds (+TS_OFFSET_S) in slot order: a minute is whole at the next second's first event
+
+    def __init__(self, emit, rpc=None, pumpfun=None):
+        """``pumpfun``: mint → is a pump.fun coin (pumpstream.Aggregator.pumpfun: the suffix, or a graduate without it)."""
+        self.emit, self.pools, self.pumpfun = emit, Pools(), pumpfun
+        self._rpc = rpc
+        self.delivered: dict[str, float] = {}                   # signature -> when it went out
+        self.wm = 0.0; self.last_amm = 0.0; self.connected: dict[str, bool] = {AMM: False, PUMP: False}
+        self.pending: Counter = Counter()                       # minute start -> transactions of it still on their way
+        self.fetching: dict[str, dict] = {}                     # signature -> {slot, minute, first, n}: cut-off transactions to fetch
+        self.waiting: list[dict] = []                           # transactions waiting for their pools' mints
+        self.stats = Counter()
+
+    @property
+    def rpc(self):
+        if self._rpc is None:
+            from ..chain.rpc import HttpSolanaRpc
+            self._rpc = HttpSolanaRpc()
+        return self._rpc
+
+    def up(self, now: float | None = None) -> bool:
+        now = time.time() if now is None else now
+        return self.connected.get(AMM, False) and now - self.last_amm < STALE_S
+
+    # ---- one transaction ----
+    def _deliver(self, sig: str, slot: int, evs: list, payer: str | None, minute: int | None) -> bool:
+        """Build and emit, once per transaction; False (kept back) while a pool's mints are unknown."""
+        if sig in self.delivered:
+            return True
+        out, unknown = build(sig, slot, evs, self.pools.map, payer, self.pumpfun)
+        if unknown:
+            return False
+        now = time.time(); self.delivered[sig] = now
+        if len(self.delivered) > 200_000:
+            self.delivered = {s: t for s, t in self.delivered.items() if now - t < 600}
+        if out:
+            self.emit(out, "helius")
+            for e in out:
+                if e["pool"] == "pump-amm" and e["action"] in ("buy", "sell"):
+                    self.wm = max(self.wm, e["timestamp"] / 1000.0)
+        return True
+
+    def on_logs(self, program: str, msg: dict) -> None:
+        r = msg["params"]["result"]; v = r["value"]; slot = int(r["context"]["slot"])
+        if program == AMM:
+            self.last_amm = time.time()
+        self.stats["msgs"] += 1
+        if v.get("err") is not None:
+            return
+        logs = v.get("logs") or []; sig = v["signature"]
+        evs = log_events(logs)
+        if any("Log truncated" in line for line in logs):         # its events are fetched whole: the logs lost some
+            if sig not in self.fetching:
+                m = minute_of(evs)
+                self.fetching[sig] = {"slot": slot, "minute": m, "first": time.time(), "n": 0}
+                if m is not None:
+                    self.pending[m] += 1
+                self.stats["truncated"] += 1
+            return
+        if not evs:
+            return
+        m = minute_of(evs)
+        if not self._deliver(sig, slot, evs, None, m):
+            self.waiting.append({"sig": sig, "slot": slot, "evs": evs, "payer": None, "minute": m})
+            if m is not None:
+                self.pending[m] += 1
+
+    # ---- the workers ----
+    async def _fetch_loop(self, stop) -> None:
+        while not (stop is not None and stop.is_set()):
+            await asyncio.sleep(BACKFILL_RETRY_S)
+            await self._fetch_round()
+
+    async def _fetch_round(self) -> None:
+        """Cut-off transactions, fetched whole in batches once confirmed; given up ``BACKFILL_GIVE_UP_S`` after first seen
+        (a processed transaction whose fork was dropped never confirms)."""
+        todo = list(self.fetching.items())[:BACKFILL_BATCH]
+        if not todo:
+            return
+        calls = [("getTransaction", [s, {"encoding": "json", "maxSupportedTransactionVersion": 1, "commitment": "confirmed"}]) for s, _ in todo]
+        try:
+            res = await asyncio.to_thread(self.rpc.batch, calls)
+        except Exception as e:
+            self.stats["fetch_errors"] += 1
+            log.warning("helius backfill batch failed: %s", type(e).__name__)
+            res = [None] * len(todo)
+        now = time.time()
+        for (sig, f), tx in zip(todo, res):
+            if tx:
+                self.fetching.pop(sig, None)
+                evs = cpi_events(tx); payer = tx["transaction"]["message"]["accountKeys"][0]
+                m = f["minute"] if f["minute"] is not None else minute_of(evs)
+                if f["minute"] is not None:
+                    self.pending[f["minute"]] -= 1
+                if evs and not self._deliver(sig, int(tx.get("slot") or f["slot"]), evs, payer, m):
+                    self.waiting.append({"sig": sig, "slot": int(tx.get("slot") or f["slot"]), "evs": evs, "payer": payer, "minute": m})
+                    if m is not None:
+                        self.pending[m] += 1
+                self.stats["backfilled"] += 1
+            elif now - f["first"] > BACKFILL_GIVE_UP_S:
+                self.fetching.pop(sig, None)
+                if f["minute"] is not None:
+                    self.pending[f["minute"]] -= 1
+                self.stats["backfill_lost"] += 1
+        self._tidy()
+
+    async def _resolve_loop(self, stop) -> None:
+        while not (stop is not None and stop.is_set()):
+            await asyncio.sleep(0.05)
+            await self._resolve_round()
+
+    async def _resolve_round(self) -> None:
+        """Transactions waiting for their pools' mints: the unknown pools read in one batch, then built again."""
+        if not self.waiting:
+            return
+        need = sorted({t["pool"] for w in self.waiting for n, p in w["evs"] if n in ("BuyEvent", "SellEvent")
+                       for t in (amm_trade(n, p),) if t["pool"] not in self.pools.map})
+        if need:
+            try:
+                self.stats["pools_read"] += await asyncio.to_thread(self.pools.resolve, self.rpc, need)
+            except Exception as e:
+                self.stats["resolve_errors"] += 1
+                log.warning("helius pool read failed: %s", type(e).__name__)
+                return
+        still = []
+        for w in self.waiting:
+            if self._deliver(w["sig"], w["slot"], w["evs"], w["payer"], w["minute"]):
+                if w["minute"] is not None:
+                    self.pending[w["minute"]] -= 1
+            else:
+                still.append(w)
+        self.waiting = still
+        self._tidy()
+
+    def _tidy(self) -> None:
+        for m in [m for m, n in self.pending.items() if n <= 0]:
+            del self.pending[m]
+
+    async def _connection(self, program: str, stop) -> None:
+        ctx = ssl.create_default_context(cafile=certifi.where()); backoff = 0.5
+        while not (stop is not None and stop.is_set()):
+            try:
+                async with websockets.connect(config.helius_wss_url(), ssl=ctx, max_size=16_000_000, ping_interval=20, ping_timeout=20) as ws:
+                    await ws.send(json.dumps({"jsonrpc": "2.0", "id": 1, "method": "logsSubscribe",
+                                              "params": [{"mentions": [program]}, {"commitment": config.HELIUS_FEED_COMMITMENT}]}))
+                    log.info("helius feed: subscribed to %s logs", program[:4]); backoff = 0.5
+                    while not (stop is not None and stop.is_set()):
+                        raw = await asyncio.wait_for(ws.recv(), timeout=30)
+                        self.stats["bytes"] += len(raw)
+                        m = orjson.loads(raw)
+                        if m.get("method") == "logsNotification":
+                            self.connected[program] = True
+                            try:
+                                self.on_logs(program, m)
+                            except Exception:
+                                self.stats["decode_errors"] += 1
+                                log.exception("helius feed: a %s notification failed to decode", program[:4])
+                        elif "error" in m:
+                            raise RuntimeError(f"logsSubscribe refused: {m['error']}")
+            except Exception as e:
+                self.stats["reconnects"] += 1
+                log.warning("helius feed (%s): %s; reconnecting in %.1fs", program[:4], str(e)[:200], backoff)
+            finally:
+                self.connected[program] = False
+            if stop is not None and stop.is_set():
+                break
+            await asyncio.sleep(backoff); backoff = min(10.0, backoff * 2)
+
+    async def run(self, stop) -> None:
+        n = await asyncio.to_thread(self.pools.seed)
+        log.info("helius feed: %d pools known from the stream's minutes", n)
+        await asyncio.gather(self._connection(AMM, stop), self._connection(PUMP, stop), self._fetch_loop(stop), self._resolve_loop(stop))
+
+    def status(self) -> dict:
+        return {**{k: int(v) for k, v in self.stats.items()}, "up": self.up(), "connected": {k[:4]: v for k, v in self.connected.items()},
+                "fetching": len(self.fetching), "waiting": len(self.waiting), "pools": len(self.pools.map), "watermark": self.wm,
+                "lag_s": round(time.time() - self.wm, 2) if self.wm else None}

fly_trader/ingest/pumpstream.py

@@ -1,8 +1,15 @@
-"""PumpAPI live stream → per-minute rich candles (Supervisor thread ``pumpstream``).
+"""PumpAPI live stream and our own feed → per-minute rich candles (Supervisor thread ``pumpstream``).
 
 ``wss://stream.pumpapi.io`` is a free, keyless firehose (~400–800 events/s, one connection per IP) whose events are
-identical to the replay archive. This worker keeps only what the selector needs: PumpSwap (``pump-amm``, SOL-quoted)
-buys and sells of pump.fun-origin mints, aggregated per (mint, minute) into the same fields ``train/mature.py``
+identical to the replay archive. From Asia it falls behind and reconnects about once a minute, losing ~40 % of the legs
+(2026-10-19). A primary feed can take over as the minutes' clock, PumpAPI's own stream staying its backup:
+``SOL_FEED=relay`` (ingest/relay_feed.py: PumpAPI's events from our relay near its source, stream_relay/) or
+``SOL_FEED=helius`` (ingest/helius_feed.py: the same events decoded from Helius). Each transaction is taken once from
+whichever feed brought it first (``Aggregator.ingest_from``), and the backup's clock counts only while the primary is down.
+This worker keeps only what the selector needs: SOL-quoted buys and sells in PumpSwap (``pump-amm``) and Meteora DLMM pools
+(``corpus_meta.UNIVERSE_POOLS``; DLMM since 2026-10-23) of pump.fun-origin mints (a ``pump`` mint, or a pump.fun graduate
+without the suffix: one whose migration the stream saw or ``corpus_meta`` holds, reloaded every 5 minutes), aggregated per
+(mint, minute) into the same fields ``train/mature.py``
 derives from the archive, with the same filters: legs in a pool created directly rather than by a pump.fun migration
 (``createPool`` with ``poolCreatedBy`` other than ``pump``; the owner can pull its unburned liquidity) are dropped — such pools
 go to ``pump_pools`` as they are created, and the blocked set is reloaded from that table (archive backfill included) at
@@ -16,7 +23,9 @@ publishes the newest complete minute for the engine the moment it is written (th
 Lifecycle: ``create`` events go to ``pump_events`` as they arrive; at ``migrate`` a ``corpus_meta`` row is written
 with the creation facts and the creator's point-in-time history (``train/corpus_meta.creator_history``, the training
 definition); 61 minutes after a graduation its own 60-minute outcome is filled from the stream's minutes so later
-graduations by the same creator see it, as in training. Minute rows older than ``PUMP_MINUTES_KEEP_DAYS`` are archived
+graduations by the same creator see it, as in training. A graduation's quote asset goes to ``corpus_meta.grad_quote`` (at the
+migration, or for an older graduate from trades in its own pool in another quote: ``corpus_meta.record_grad_quotes``), so its
+quote-unit inputs are read as SOL only when they are (``corpus_meta.sol_select``). Minute rows older than ``PUMP_MINUTES_KEEP_DAYS`` are archived
 to ``data/corpus/stream/<day>.parquet`` before removal. Database failures keep the data in memory for the next attempt.
 """
 from __future__ import annotations
@@ -42,7 +51,7 @@ from .. import config
 from ..db.apilog import record_event
 from ..db.connection import transaction
 from ..logging_setup import setup
-from ..train.corpus_meta import CURVE_COLS, blocked_pool_ids, creator_history, curve_facts
+from ..train.corpus_meta import CURVE_COLS, UNIVERSE_POOLS, blocked_pool_ids, creator_history, curve_facts, pumpfun_graduates, record_grad_quotes
 from ..train.flow import minute_wallet_cols
 
 log = logging.getLogger(__name__)
@@ -51,8 +60,11 @@ RESQ_BAND = (0.001, 100000.0)     # train/mature.py: quote_in_pool BETWEEN 0.001
 PRICE_BAND = 50.0                  # train/mature.py: within 50x of the trailing median of the mint's previous 200 legs
 REF_LEGS = 200
 FLUSH_GRACE_S = 2.0
-FLUSH_CHECK_S = 0.25         # how often complete minutes are looked for: a written minute is published at once (live money first)
+FLUSH_CHECK_S = 0.05         # how often complete minutes are looked for: a written minute is published at once (live money first)
 FLUSH_FALLBACK_S = 15.0
+HELIUS_GRACE_S = 0.5         # our feed's stamps are its blocks' seconds (+0.9 s) in slot order: a minute is whole at the next second's first event
+HOLD_MAX_S = 3.0             # the longest a minute waits for its cut-off transactions and unknown pools (ingest/helius_feed.py)
+CLAIM_KEEP_S = 900.0
 MAX_PENDING_CREATES = 200_000
 
 
@@ -79,19 +91,66 @@ class Aggregator:
         self.curve: dict[str, dict] = {}                                   # mint → bonding-curve wallets since its create (corpus_meta.curve_facts)
         self.pending_creates: list[tuple[str, dict]] = []                 # creates not yet written to pump_events
         self.blocked: set[str] = set()                                     # pool ids of directly created (custom) PumpSwap pools
+        self.grads: set[str] = set()                                       # pump.fun graduates whose mint lacks the "pump" suffix
+        self.quote_seen: set[tuple] = set(); self.pending_quotes: list[tuple] = []   # (mint, pool, quote) of graduates' pools in another quote
         self.pending_pools: list[tuple] = []                               # custom pools not yet written to pump_pools
         self.flushed_through: datetime | None = None                       # start of the newest complete minute written
         self.insiders: dict[str, frozenset] = {}                           # mint → creator/bundle/early wallets (token_insiders)
         self.skill: dict | None = None; self.skill_day: str | None = None  # wallet → skill decile for the current UTC day (train/wallet_skill.py)
         self.stats = {"events": 0, "trades": 0, "dropped_band": 0, "dropped_late": 0, "dropped_custom_pool": 0, "flushed_minutes": 0, "flushed_rows": 0, "creates": 0, "migrates": 0,
-                      "custom_pools": 0, "blocked_pools": 0, "reconnects": 0, "outcomes_filled": 0, "started_at": datetime.now(timezone.utc).isoformat()}
+                      "custom_pools": 0, "blocked_pools": 0, "reconnects": 0, "outcomes_filled": 0, "duplicates": 0, "started_at": datetime.now(timezone.utc).isoformat()}
+        self.feed = None                                                   # our own feed (ingest/helius_feed.HeliusFeed): the minutes' clock while it is up
+        self.wm_pumpapi = 0.0                                              # PumpAPI's newest trade time: the clock while our feed is down
+        self.claims: dict[tuple, str] = {}; self.claim_q: deque = deque()  # (signature, pool/kind) -> the feed whose copy was taken
+        self.held: dict[int, float] = {}                                   # minute -> when its flush first waited for our feed
+
+    def key(self, e: dict) -> tuple | None:
+        """One transaction's events in one pool (or of one kind): what the two feeds' copies have in common."""
+        sig, a = e.get("signature"), e.get("action")
+        if not sig:
+            return None
+        if a in ("buy", "sell"):
+            return (sig, "curve", e.get("mint")) if e.get("pool") == "pump" else (sig, e.get("poolId") or "")
+        if a in ("create", "migrate"):
+            return (sig, a)
+        if a == "createPool":
+            return (sig, a, e.get("poolId"))
+        return None
+
+    def ingest_from(self, e: dict, source: str) -> None:
+        """``ingest`` once per transaction across the two feeds: whichever brought it first owns it and the other's
+        copies are dropped (a feed may send one transaction as several events of one key: all taken). An event without a
+        signature cannot be matched: the backup's is dropped while the primary feed is up."""
+        if self.feed is None:                            # PumpAPI alone (config.SOL_FEED = pumpapi)
+            return self.ingest(e, source)
+        k = self.key(e)
+        if k is None:
+            if source != getattr(self.feed, "source", "helius") and self.feed.up():
+                self.stats["duplicates"] += 1
+                return
+        else:
+            by = self.claims.get(k)
+            if by is not None and by != source:
+                self.stats["duplicates"] += 1
+                return
+            if by is None:
+                self.claims[k] = source; self.claim_q.append((time.time(), k))
+        self.ingest(e, source)
+
+    def expire_claims(self, now: float) -> None:
+        while self.claim_q and now - self.claim_q[0][0] > CLAIM_KEEP_S:
+            self.claims.pop(self.claim_q.popleft()[1], None)
 
     def row(self, minute: int, mint: str) -> Minute | None:
         """The minute's candle for a mint: the pool with the most legs (as in training)."""
         pools = self.minutes.get(minute, {}).get(mint)
         return max(pools.values(), key=lambda r: (r.nb + r.ns, r.buy + r.sell)) if pools else None
 
-    def ingest(self, e: dict) -> None:
+    def pumpfun(self, mint) -> bool:
+        """A pump.fun coin: the ``pump`` suffix, or a graduate without it (its migration seen here or in ``corpus_meta``)."""
+        return bool(mint) and (str(mint).endswith("pump") or mint in self.grads)
+
+    def ingest(self, e: dict, source: str = "pumpapi") -> None:
         self.stats["events"] += 1
         a = e.get("action"); pool = e.get("pool"); mint = e.get("mint"); ts = e.get("timestamp")
         if a == "createPool" and pool == "pump-amm" and (e.get("poolCreatedBy") or "custom") != "pump":
@@ -106,7 +165,13 @@ class Aggregator:
             self._curve(e)
             return
         if a in ("buy", "sell"):
-            if pool != "pump-amm" or e.get("quoteMint") != WSOL or not str(mint).endswith("pump"):
+            if pool not in UNIVERSE_POOLS or not self.pumpfun(mint):
+                return
+            if e.get("quoteMint") != WSOL:
+                if pool == "pump-amm":                  # maybe the graduate's own pool, seeded in another quote: its graduation's quote
+                    k = (mint, e.get("poolId"), e.get("quoteMint"))
+                    if k[1] and k[2] and k not in self.quote_seen:
+                        self.quote_seen.add(k); self.pending_quotes.append(k)
                 return
             if e.get("poolId") in self.blocked:
                 self.stats["dropped_custom_pool"] += 1
@@ -115,6 +180,8 @@ class Aggregator:
             if not price or price <= 0 or q is None or not (RESQ_BAND[0] <= float(q) <= RESQ_BAND[1]):
                 return
             ts_s = ts / 1000.0; self.max_event_s = max(self.max_event_s, ts_s); self.last_event_wall = time.time()
+            if source == "pumpapi":
+                self.wm_pumpapi = max(self.wm_pumpapi, ts_s)
             day = int(ts_s // 86400)
             if self.ref_day is None or day > self.ref_day:      # a late event from the previous day never wipes today's references
                 self.ref = {}; self.ref_day = day
@@ -166,6 +233,8 @@ class Aggregator:
                 self.curve = {k: v for k, v in self.curve.items() if v["ts"] >= cutoff}
         elif a == "migrate" and pool == "pump-amm":
             self.stats["migrates"] += 1
+            if not str(mint).endswith("pump"):
+                self.grads.add(mint)                # a pump.fun graduate without the suffix: its PumpSwap legs are universe legs
             self.write_creates()                    # the creator's own earlier creates must be visible to the history query
             self._graduation(e)
 
@@ -205,6 +274,19 @@ class Aggregator:
     def block(self, pool_ids) -> None:
         self.blocked.update(pool_ids); self.stats["blocked_pools"] = len(self.blocked)
 
+    def write_quotes(self) -> int:
+        """Graduation quotes learnt from graduates' own pools (``corpus_meta.record_grad_quotes``); kept on failure."""
+        rows, self.pending_quotes = self.pending_quotes, []
+        if not rows:
+            return 0
+        try:
+            with transaction() as conn:
+                return record_grad_quotes(conn, rows)
+        except Exception:
+            self.pending_quotes = (rows + self.pending_quotes)[-MAX_PENDING_CREATES:]
+            log.exception("graduation quotes failed; %d queued for the next attempt", len(self.pending_quotes))
+            return 0
+
     def write_pools(self) -> int:
         """Persist custom pools seen on the stream (training excludes the same pools); on failure they stay queued."""
         rows, self.pending_pools = self.pending_pools, []
@@ -233,8 +315,8 @@ class Aggregator:
                 ct = datetime.fromtimestamp(c["ts"] / 1000, timezone.utc) if c else None
                 h = creator_history(conn, c.get("creator") if c else None, ct, g)
                 conn.execute("""INSERT INTO corpus_meta (mint, graduated_at, create_ts, creator, dev_sol, dev_tokens, dev_share, supply, mayhem, uri, name, symbol, ttg_min, rq0, pool_id,
-                                                         prior_launches, prior_grads, prior_known, prior_rug_share, prior_moon_share)
-                                VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s) ON CONFLICT (mint) DO UPDATE SET
+                                                         prior_launches, prior_grads, prior_known, prior_rug_share, prior_moon_share, grad_quote)
+                                VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s) ON CONFLICT (mint) DO UPDATE SET
                                   graduated_at = COALESCE(corpus_meta.graduated_at, EXCLUDED.graduated_at),
                                   create_ts = COALESCE(corpus_meta.create_ts, EXCLUDED.create_ts), creator = COALESCE(corpus_meta.creator, EXCLUDED.creator),
                                   dev_sol = COALESCE(corpus_meta.dev_sol, EXCLUDED.dev_sol), dev_tokens = COALESCE(corpus_meta.dev_tokens, EXCLUDED.dev_tokens),
@@ -244,12 +326,13 @@ class Aggregator:
                                   ttg_min = COALESCE(corpus_meta.ttg_min, EXCLUDED.ttg_min), rq0 = COALESCE(corpus_meta.rq0, EXCLUDED.rq0), pool_id = COALESCE(corpus_meta.pool_id, EXCLUDED.pool_id),
                                   prior_launches = COALESCE(corpus_meta.prior_launches, EXCLUDED.prior_launches), prior_grads = COALESCE(corpus_meta.prior_grads, EXCLUDED.prior_grads),
                                   prior_known = COALESCE(corpus_meta.prior_known, EXCLUDED.prior_known), prior_rug_share = COALESCE(corpus_meta.prior_rug_share, EXCLUDED.prior_rug_share),
-                                  prior_moon_share = COALESCE(corpus_meta.prior_moon_share, EXCLUDED.prior_moon_share), updated_at = now()""",
+                                  prior_moon_share = COALESCE(corpus_meta.prior_moon_share, EXCLUDED.prior_moon_share),
+                                  grad_quote = COALESCE(corpus_meta.grad_quote, EXCLUDED.grad_quote), updated_at = now()""",
                              (mint, g, ct, c.get("creator") if c else None, c.get("dev_sol") if c else None, c.get("dev_tokens") if c else None,
                               (float(c["dev_tokens"]) / float(c["supply"])) if c and c.get("dev_tokens") and c.get("supply") else None,
                               c.get("supply") if c else None, c.get("mayhem") if c else None, c.get("uri") if c else None, c.get("name") if c else None, c.get("symbol") if c else None,
                               ((e["timestamp"] - c["ts"]) / 60000.0) if c else None, e.get("quoteInPool"), e.get("poolId"),
-                              h["prior_launches"], h["prior_grads"], h["prior_known"], h["prior_rug_share"], h["prior_moon_share"]))
+                              h["prior_launches"], h["prior_grads"], h["prior_known"], h["prior_rug_share"], h["prior_moon_share"], e.get("quoteMint")))
                 conn.execute("INSERT INTO corpus_tokens (mint, graduated_at, grad_slot, source, status) VALUES (%s,%s,%s,'stream','pending') ON CONFLICT (mint) DO NOTHING",
                              (mint, g, int(e.get("block") or 0)))
                 st = self.curve.pop(mint, None)
@@ -296,13 +379,28 @@ class Aggregator:
         return len(rows)
 
     def flush_bound(self, now: float) -> int:
-        """Minutes strictly before this start are complete: event-time watermark, or the wall-clock fallback once no trade
-        has arrived for ``FLUSH_FALLBACK_S`` (a lagging stream still delivers the minute's events, so it waits for them)."""
+        """Minutes strictly before this start are complete. The clock is our feed's while it is up (its newest PumpSwap
+        stamp: its events come in slot order), else PumpAPI's event-time watermark, or the wall-clock fallback once no
+        trade has arrived for ``FLUSH_FALLBACK_S`` (a lagging stream still delivers the minute's events, so it waits for
+        them). A minute whose cut-off transactions or unknown pools our feed is still fetching waits for them, at most
+        ``HOLD_MAX_S``."""
         cur = int(now // 60) * 60
-        wm = int((self.max_event_s - FLUSH_GRACE_S) // 60) * 60
+        feed = self.feed
+        if feed is not None and feed.up(now):
+            wm = int((feed.wm - getattr(feed, "grace_s", HELIUS_GRACE_S)) // 60) * 60
+        else:
+            wm = int(((self.wm_pumpapi if feed is not None else self.max_event_s) - FLUSH_GRACE_S) // 60) * 60
         if now - self.last_event_wall >= FLUSH_FALLBACK_S:
             wm = max(wm, int((now - FLUSH_FALLBACK_S) // 60) * 60)
-        return min(cur, wm)
+        bound = min(cur, wm)
+        if feed is not None:
+            for m in sorted(m for m, n in feed.pending.items() if n > 0 and m < bound):
+                if now - self.held.setdefault(m, now) < HOLD_MAX_S:
+                    bound = m
+                    break
+            for m in [m for m in self.held if m < bound - 600]:
+                del self.held[m]
+        return bound
 
 
 def fill_outcomes() -> int:
@@ -403,82 +501,120 @@ def load_skill(agg: Aggregator, now: float | None = None) -> None:
 
 
 def _load_blocked(agg: Aggregator) -> None:
-    """Union the custom pools in ``pump_pools`` (stream rows and the archive backfill) into the blocked set."""
+    """Union the custom pools in ``pump_pools`` (stream rows and the archive backfill) into the blocked set, and the pump.fun
+    graduates without the ``pump`` suffix (``corpus_meta``: the archive's and the stream's migrations) into ``grads``."""
     try:
         with transaction() as conn:
             agg.block(blocked_pool_ids(conn))
+            agg.grads.update(pumpfun_graduates(conn))
     except Exception:
         log.exception("custom pool load failed; retried in 5 min")
 
 
-async def _run(stop: threading.Event | None, agg: Aggregator) -> None:
+async def _pumpapi(stop: threading.Event | None, agg: Aggregator, io: dict) -> None:
+    """PumpAPI's stream: every event to the aggregator (our feed's backup while it runs, Aggregator.ingest_from)."""
     ctx = ssl.create_default_context(cafile=certifi.where()); backoff = 1.0
-    _load_blocked(agg); last_pools = time.time(); last_ins = 0.0
-    try:
-        load_skill(agg)
-    except Exception:
-        log.exception("wallet skill load failed; retried in 5 min")
-    last_status = last_flush = last_outcomes = 0.0; last_archive = time.time() - 3000; last_msg = 0.0; rate_n = 0; rate_t = time.time()
-    bg: dict[str, asyncio.Task | None] = {"archive": None, "outcomes": None}
     while not (stop is not None and stop.is_set()):
         try:
             async with websockets.connect(config.PUMPSTREAM_URL, ssl=ctx, max_size=8_000_000, ping_interval=20, ping_timeout=20) as ws:
-                log.info("pumpstream connected"); backoff = 1.0
+                log.info("pumpstream connected"); backoff = 1.0; io["connected"] = True
                 while not (stop is not None and stop.is_set()):
                     try:
                         msg = await asyncio.wait_for(ws.recv(), timeout=30)
                     except asyncio.TimeoutError:
                         log.warning("pumpstream: no events for 30 s; reconnecting"); break
-                    last_msg = time.time(); rate_n += 1
+                    io["last_msg"] = time.time(); io["rate_n"] += 1
                     try:
                         e = orjson.loads(msg)
                     except orjson.JSONDecodeError:
                         continue
                     if isinstance(e, dict):
-                        agg.ingest(e)
-                    now = time.time()
-                    if now - last_flush >= FLUSH_CHECK_S:
-                        before = agg.flushed_through
-                        try:
-                            agg.flush(agg.flush_bound(now))
-                        except Exception:
-                            log.exception("minute flush failed; rows kept for the next attempt")
-                        last_flush = now
-                        if agg.flushed_through != before:
-                            last_status = 0.0      # a minute was written: the engine hears of it now, not at the next 5 s status
-                    if now - last_pools >= 300:
-                        _load_blocked(agg); last_pools = now
-                        try:
-                            load_skill(agg, now)
-                        except Exception:
-                            log.exception("wallet skill load failed; retried in 5 min")
-                    if now - last_ins >= 60:
-                        _load_insiders(agg); last_ins = now
-                    if now - last_status >= 5.0:
-                        agg.write_creates(); agg.write_pools()
-                        _status(agg, {"events_per_s": rate_n / max(now - rate_t, 1e-9), "pending_minutes": len(agg.minutes), "lag_s": now - last_msg, "connected": True,
-                                      "flushed_through": agg.flushed_through.isoformat() if agg.flushed_through else None,
-                                      "event_watermark": datetime.fromtimestamp(agg.max_event_s, timezone.utc).isoformat() if agg.max_event_s else None})
-                        rate_n = 0; rate_t = now; last_status = now
-                    if now - last_outcomes >= 60 and (bg["outcomes"] is None or bg["outcomes"].done()):
-                        bg["outcomes"] = asyncio.create_task(asyncio.to_thread(_logged, "stream outcomes filled", fill_outcomes)); last_outcomes = now
-                    if now - last_archive >= 3600 and (bg["archive"] is None or bg["archive"].done()):
-                        bg["archive"] = asyncio.create_task(asyncio.to_thread(_logged, "archived old minute rows", archive_old, config.PUMP_MINUTES_KEEP_DAYS)); last_archive = now
+                        agg.ingest_from(e, "pumpapi")
         except Exception as e:
             agg.stats["reconnects"] += 1; log.warning("pumpstream: %s; reconnecting in %.0fs", e, backoff)
-            _status(agg, {"connected": False, "last_error": str(e)[:200]})
+            io["connected"] = False; io["last_error"] = str(e)[:200]
             await asyncio.sleep(backoff); backoff = min(60.0, backoff * 2)
+        io["connected"] = False
+
+
+async def _housekeeping(stop: threading.Event | None, agg: Aggregator, io: dict) -> None:
+    """The minutes' flush on its own clock (``FLUSH_CHECK_S``: a feed's reconnect never holds a minute back), the
+    engine woken the moment one is written (agent/live_first.minute_published), then the status and the periodic loads."""
+    last_pools = time.time(); last_ins = 0.0; last_status = last_outcomes = 0.0; last_archive = time.time() - 3000
+    bg: dict[str, asyncio.Task | None] = {"archive": None, "outcomes": None, "blocked": None}
+    while not (stop is not None and stop.is_set()):
+        await asyncio.sleep(FLUSH_CHECK_S)
+        now = time.time()
+        try:
+            before = agg.flushed_through
+            try:
+                agg.flush(agg.flush_bound(now))
+            except Exception:
+                log.exception("minute flush failed; rows kept for the next attempt")
+            published = agg.flushed_through != before
+            if published or now - last_status >= 5.0:     # a minute was written: the engine hears of it now, not at the next 5 s status
+                agg.write_creates(); agg.write_pools(); agg.write_quotes()
+                _status(agg, {"events_per_s": io["rate_n"] / max(now - io["rate_t"], 1e-9), "pending_minutes": len(agg.minutes), "lag_s": now - io["last_msg"],
+                              "connected": io["connected"] or bool(agg.feed and agg.feed.up(now)), "pumpapi_connected": io["connected"], "last_error": io["last_error"],
+                              "source": agg.feed.source if agg.feed is not None and agg.feed.up(now) else "pumpapi", "feed": agg.feed.status() if agg.feed is not None else None,
+                              "flushed_through": agg.flushed_through.isoformat() if agg.flushed_through else None,
+                              "event_watermark": datetime.fromtimestamp(agg.max_event_s, timezone.utc).isoformat() if agg.max_event_s else None})
+                io["rate_n"] = 0; io["rate_t"] = now; last_status = now
+                if published:
+                    from ..agent import live_first
+                    live_first.minute_published()
+            agg.expire_claims(now)
+            if now - last_pools >= 300:
+                if bg["blocked"] is None or bg["blocked"].done():      # on a thread: the minutes' flush never waits for the read
+                    bg["blocked"] = asyncio.create_task(asyncio.to_thread(_load_blocked, agg))
+                last_pools = now
+                try:
+                    load_skill(agg, now)
+                except Exception:
+                    log.exception("wallet skill load failed; retried in 5 min")
+            if now - last_ins >= 60:
+                _load_insiders(agg); last_ins = now
+            if now - last_outcomes >= 60 and (bg["outcomes"] is None or bg["outcomes"].done()):
+                bg["outcomes"] = asyncio.create_task(asyncio.to_thread(_logged, "stream outcomes filled", fill_outcomes)); last_outcomes = now
+            if now - last_archive >= 3600 and (bg["archive"] is None or bg["archive"].done()):
+                bg["archive"] = asyncio.create_task(asyncio.to_thread(_logged, "archived old minute rows", archive_old, config.PUMP_MINUTES_KEEP_DAYS)); last_archive = now
+        except Exception:
+            log.exception("pumpstream housekeeping failed (retried at once)")
     for t in bg.values():
         if t is not None:
             try:
                 await t
             except Exception:
                 pass
+
+
+async def _run(stop: threading.Event | None, agg: Aggregator) -> None:
+    """PumpAPI's stream, a primary feed (config.SOL_FEED = relay: our relay near PumpAPI; helius: our own decoder) that
+    is the minutes' clock while up, PumpAPI's own stream its backup, and the flush, side by side."""
+    _load_blocked(agg)
+    try:
+        load_skill(agg)
+    except Exception:
+        log.exception("wallet skill load failed; retried in 5 min")
+    io = {"connected": False, "last_msg": 0.0, "rate_n": 0, "rate_t": time.time(), "last_error": None}
+    jobs = [_pumpapi(stop, agg, io), _housekeeping(stop, agg, io)]
+    def emit(events, source):
+        for e in events:
+            agg.ingest_from(e, source)
+    if config.SOL_FEED == "helius":
+        from .helius_feed import HeliusFeed
+        agg.feed = HeliusFeed(emit, pumpfun=agg.pumpfun)
+        jobs.append(agg.feed.run(stop))
+    elif config.SOL_FEED == "relay":                    # PumpAPI's events from our relay near its source (stream_relay/)
+        from .relay_feed import RelayFeed
+        agg.feed = RelayFeed(emit)
+        jobs.append(agg.feed.run(stop))
+    await asyncio.gather(*jobs)
     try:
         agg.flush(int(time.time() // 60) * 60 + 60)
     except Exception:
         log.exception("final minute flush failed")
-    agg.write_creates(); agg.write_pools()
+    agg.write_creates(); agg.write_pools(); agg.write_quotes()
 
 
 def main(stop_event: threading.Event | None = None) -> None:

fly_trader/ingest/relay_feed.py

@@ -0,0 +1,109 @@
+"""The stream relay's client: PumpAPI's events, filtered and trimmed by stream_relay/relay.py on a server near PumpAPI,
+over one compressed connection that resumes where it left off (nothing lost within the relay's ring).
+
+With ``SOL_FEED=relay`` it is the minutes' clock (ingest/pumpstream.Aggregator.flush_bound: the relay's watermark as of
+the events it has sent, ``grace_s`` back, as PumpAPI's own stream) and this machine's own PumpAPI connection is its
+backup; each transaction is taken once (``Aggregator.ingest_from``). ``check`` connects without switching anything and
+reports what arrives (``fly-trader relay-check``)."""
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import ssl
+import time
+from collections import Counter
+
+import certifi
+import orjson
+import websockets
+
+from .. import config
+
+log = logging.getLogger(__name__)
+GRACE_S = 2.0                # the events carry PumpAPI's stamps (its receive times): the grace of its own stream (pumpstream.FLUSH_GRACE_S)
+STALE_S = 5.0                # the relay heartbeats every second: silence this long means it is down
+
+
+class RelayFeed:
+    source = "relay"
+    grace_s = GRACE_S
+
+    def __init__(self, emit):
+        self.emit = emit
+        self.next_seq: int | None = None                    # the next event wanted: a reconnect resumes there
+        self.wm = 0.0; self.last_msg = 0.0; self.connected = False; self.upstream_up = False
+        self.pending: Counter = Counter()                   # nothing arrives later than its batch: no minute waits on the relay
+        self.stats = Counter()
+
+    def up(self, now: float | None = None) -> bool:
+        now = time.time() if now is None else now
+        return self.connected and self.upstream_up and now - self.last_msg < STALE_S
+
+    def on_message(self, m: dict) -> None:
+        self.last_msg = time.time()
+        if "gap" in m:                                      # the relay's ring no longer holds what this client missed
+            a, b = m["gap"]; self.stats["gaps"] += 1; self.stats["lost"] += max(0, b - a); self.next_seq = b
+            log.warning("stream relay: %d events lost while disconnected (beyond its buffer)", b - a)
+            return
+        if "hello" in m:
+            self.next_seq = m["hello"]["next"]
+            return
+        evs = m.get("events") or []
+        if self.next_seq is not None and m["from"] != self.next_seq:
+            log.warning("stream relay: batch from %s, expected %s", m["from"], self.next_seq)
+        if evs:
+            self.emit(evs, self.source); self.stats["events"] += len(evs)
+        self.next_seq = m["from"] + len(evs)
+        self.wm = max(self.wm, float(m.get("wm") or 0.0)); self.upstream_up = bool(m.get("up"))
+
+    async def run(self, stop) -> None:
+        if not (config.STREAM_RELAY_URL and config.STREAM_RELAY_TOKEN):
+            log.error("SOL_FEED=relay needs STREAM_RELAY_URL and STREAM_RELAY_TOKEN (stream_relay/README.md): PumpAPI's stream alone meanwhile")
+            return
+        tls = ssl.create_default_context(cafile=config.STREAM_RELAY_CA_FILE or certifi.where()) if config.STREAM_RELAY_URL.startswith("wss") else None
+        backoff = 0.5
+        while not (stop is not None and stop.is_set()):
+            try:
+                async with websockets.connect(config.STREAM_RELAY_URL, ssl=tls, additional_headers={"Authorization": f"Bearer {config.STREAM_RELAY_TOKEN}"},
+                                              compression="deflate", max_size=64_000_000, ping_interval=10, ping_timeout=10, open_timeout=10) as ws:
+                    await ws.send(json.dumps({"resume": self.next_seq}))
+                    self.connected = True; backoff = 0.5
+                    log.info("stream relay connected (resuming at %s)", self.next_seq)
+                    while not (stop is not None and stop.is_set()):
+                        self.on_message(orjson.loads(await asyncio.wait_for(ws.recv(), timeout=STALE_S * 2)))
+            except Exception as e:
+                self.stats["reconnects"] += 1
+                log.warning("stream relay: %s; reconnecting in %.1fs", str(e)[:200], backoff)
+            finally:
+                self.connected = False
+            if stop is not None and stop.is_set():
+                break
+            await asyncio.sleep(backoff); backoff = min(10.0, backoff * 2)
+
+    def status(self) -> dict:
+        return {**{k: int(v) for k, v in self.stats.items()}, "up": self.up(), "connected": self.connected, "upstream_up": self.upstream_up,
+                "next_seq": self.next_seq, "watermark": self.wm, "lag_s": round(time.time() - self.wm, 2) if self.wm else None}
+
+
+def check(seconds: float = 30.0) -> dict:
+    """Connect to the relay for ``seconds`` without touching the live stream and report what arrived."""
+    if not (config.STREAM_RELAY_URL and config.STREAM_RELAY_TOKEN):
+        return {"error": "STREAM_RELAY_URL and STREAM_RELAY_TOKEN are not set in .env (stream_relay/README.md)"}
+    kinds: Counter = Counter(); lags: list[float] = []
+    feed = RelayFeed(lambda evs, src: kinds.update((e.get("pool"), e.get("action")) for e in evs))
+
+    async def go():
+        stop = asyncio.Event(); task = asyncio.create_task(feed.run(stop)); t0 = time.time()
+        while time.time() - t0 < seconds:
+            await asyncio.sleep(1.0)
+            if feed.wm:
+                lags.append(time.time() - feed.wm)
+        stop.set()
+        await asyncio.sleep(1.5); task.cancel()
+
+    asyncio.run(go())
+    lags.sort()
+    out = {"seconds": seconds, "events_per_s": round(sum(kinds.values()) / seconds, 1), "by_kind": {f"{p}/{a}": n for (p, a), n in kinds.most_common()},
+           "lag_s_p50": round(lags[len(lags) // 2], 2) if lags else None, "lag_s_max": round(lags[-1], 2) if lags else None, **feed.status()}
+    return out

fly_trader/ingest/replay_pull.py

@@ -7,9 +7,12 @@ reserves; ``create`` with the creator wallet and metadata URI; ``migrate`` (grad
 
 This worker downloads ``REPLAY_PARALLEL`` hours at a time (measured ~2–4 MB/s per stream), parses each in one
 thread and writes, per hour, ``data/corpus/replay/<date>/<HH>_trades.parquet`` (pump.fun bonding-curve and
-PumpSwap buys/sells, one row per trader leg; signatures and per-mint constants are left out to keep it ~70 MB/hour, the
-lifecycle table carries creator, pool id, metadata URI and the reserves at migration) and ``<HH>_events.parquet`` (every non-trade lifecycle event across
-all pools, small). Hours are processed newest first so the current regime lands first, and hours that close while the backfill runs
+PumpSwap buys/sells in any quote, and since 2026-10-23 every other venue's SOL-quoted buys/sells: Meteora DLMM, DAMM,
+Raydium, Orca, other launchpads' curves; one row per trader leg; signatures and per-mint constants are left out to keep it
+~90 MB/hour, the lifecycle table carries creator, pool id, metadata URI and the reserves at migration) and
+``<HH>_events.parquet`` (every non-trade lifecycle event across all pools, small; the quote mint since 2026-10-23). Both are
+written atomically; the trades file is stamped with what it keeps (``TRADES_VERSION``), and ``refetch_main`` downloads
+the hours stamped otherwise again in its own process (``fly-trader refetch-archive``). Hours are processed newest first so the current regime lands first, and hours that close while the backfill runs
 are fetched ahead of it, so the archive stays within ~2 hours of live; the registry is ``replay_hours``. The compressed download is a temporary file and is removed after a successful parse — the
 public archive remains the source of truth. Downstream: ``train/replay_assemble.py`` turns days into per-token
 candle/trade files for the feature builder.
@@ -19,6 +22,7 @@ from __future__ import annotations
 import io
 import json
 import logging
+import os
 import queue
 import threading
 import time
@@ -40,7 +44,9 @@ from .corpus_pull import _db_retry, _sleep
 log = logging.getLogger(__name__)
 HOUR_SQL = ("INSERT INTO replay_hours (hour, status, last_error) VALUES (%s, %s, %s) "
             "ON CONFLICT (hour) DO UPDATE SET status = EXCLUDED.status, last_error = EXCLUDED.last_error, done_at = now()")
-TRADE_POOLS = {"pump", "pump-amm"}
+TRADE_POOLS = {"pump", "pump-amm"}          # kept in any quote; every other venue's legs are kept when SOL-quoted
+WSOL = "So11111111111111111111111111111111111111112"
+TRADES_VERSION = "pumpfun+sol-1"             # the trades file's ``fly_pools`` stamp: what its legs cover (refetch_main)
 SKIP_ACTIONS = {"buy", "sell", "transfer", "add", "remove", "claimCreatorFees"}
 TRADE_SCHEMA = pa.schema([("ts", pa.timestamp("ms", tz="UTC")), ("slot", pa.int64()), ("pool", pa.dictionary(pa.int8(), pa.string())), ("mint", pa.string()),
                           ("trader", pa.string()), ("side", pa.int8()), ("sol", pa.float64()), ("tokens", pa.float64()), ("price", pa.float64()),
@@ -50,7 +56,8 @@ EVENT_SCHEMA = pa.schema([("ts", pa.timestamp("ms", tz="UTC")), ("slot", pa.int6
                           ("mint", pa.string()), ("pool_id", pa.string()), ("signer", pa.string()), ("creator_fee_addr", pa.string()), ("name", pa.string()),
                           ("symbol", pa.string()), ("uri", pa.string()), ("supply", pa.float64()), ("decimals", pa.int16()), ("token_program", pa.string()),
                           ("initial_buy", pa.float64()), ("quote_amount", pa.float64()), ("quote_in_pool", pa.float64()), ("tokens_in_pool", pa.float64()),
-                          ("mayhem", pa.bool_()), ("pool_created_by", pa.string()), ("mint_authority", pa.string()), ("freeze_authority", pa.string())])
+                          ("mayhem", pa.bool_()), ("pool_created_by", pa.string()), ("mint_authority", pa.string()), ("freeze_authority", pa.string()),
+                          ("quote_mint", pa.string())])
 
 
 def _f(x) -> float | None:
@@ -86,7 +93,7 @@ def parse_hour(path: Path) -> tuple[pa.Table, pa.Table, int]:
                 continue
             tsdt = datetime.fromtimestamp(int(ts) / 1000, timezone.utc)
             if a in ("buy", "sell"):
-                if pool not in TRADE_POOLS:
+                if pool not in TRADE_POOLS and not (pool and e.get("quoteMint") == WSOL):
                     continue
                 legs = e.get("breakdown") or [{"action": a, "trader": e.get("txSigner"), "tokenAmount": e.get("tokenAmount"), "quoteAmount": _q(e, "quoteAmount", "solAmount")}]
                 vq = _q(e, "vQuoteInBondingCurve", "vSolInBondingCurve") if pool == "pump" else _q(e, "virtualQuoteInPool", "virtualSolInPool")
@@ -104,9 +111,26 @@ def parse_hour(path: Path) -> tuple[pa.Table, pa.Table, int]:
                 E["initial_buy"].append(_f(e.get("initialBuy"))); E["quote_amount"].append(_f(_q(e, "quoteAmount", "solAmount"))); E["quote_in_pool"].append(_f(_q(e, "quoteInPool", "solInPool")))
                 E["tokens_in_pool"].append(_f(e.get("tokensInPool"))); E["mayhem"].append(bool(e.get("mayhemMode")) if e.get("mayhemMode") is not None else None)
                 E["pool_created_by"].append(e.get("poolCreatedBy")); E["mint_authority"].append(e.get("mintAuthority")); E["freeze_authority"].append(e.get("freezeAuthority"))
+                E["quote_mint"].append(e.get("quoteMint"))
     return pa.table(T, schema=TRADE_SCHEMA), pa.table(E, schema=EVENT_SCHEMA), n
 
 
+def write_hour(day: Path, h: datetime, trades: pa.Table, events: pa.Table) -> None:
+    """The hour's two files, each written atomically (a reader never meets half a file, and a rewrite by ``refetch_main``
+    replaces it whole), the trades file stamped with what its legs cover (``TRADES_VERSION``)."""
+    day.mkdir(parents=True, exist_ok=True)
+    trades = trades.replace_schema_metadata({**(trades.schema.metadata or {}), b"fly_pools": TRADES_VERSION.encode()})
+    for t, name in ((trades, f"{h:%H}_trades.parquet"), (events, f"{h:%H}_events.parquet")):
+        tmp = day / f"{name}.{os.getpid()}.{threading.get_ident()}.tmp"
+        pq.write_table(t, tmp, compression="zstd"); tmp.replace(day / name)
+
+
+def trades_version(path) -> str | None:
+    """The ``fly_pools`` stamp of an hour's trades file (None: written before 2026-10-23, PumpSwap and the curve only)."""
+    v = (pq.read_schema(path).metadata or {}).get(b"fly_pools")
+    return v.decode() if v else None
+
+
 def refetch_missing_pool_id() -> int:
     """Hours whose trades file predates the ``pool_id`` column (written 2026-08-20..09-13 by an older parser) are marked
     ``refetch``: ``plan_hours`` downloads them again and ``parse_hour`` writes the column, so the archive applies the live
@@ -175,7 +199,8 @@ def _download(client: httpx.Client, hour: datetime, tmp: Path, stop: threading.E
 
 
 class _Status:
-    def __init__(self, total: int):
+    def __init__(self, total: int, key: str = "replay_status"):
+        self.key = key
         self.s = {"hours_total": total, "hours_done": 0, "trades": 0, "events": 0, "bytes": 0, "started_at": datetime.now(timezone.utc).isoformat(), "errors": 0}
         self.lock = threading.Lock(); self.last = 0.0; self.t0 = time.time()
 
@@ -192,8 +217,8 @@ class _Status:
             self.last = time.time(); payload = dict(self.s)
         try:
             with transaction() as conn:
-                conn.execute("INSERT INTO ui_settings (key, value) VALUES ('replay_status', %s) ON CONFLICT (key) DO UPDATE SET value = EXCLUDED.value, updated_at = now()",
-                             (json.dumps(payload, default=str),))
+                conn.execute("INSERT INTO ui_settings (key, value) VALUES (%s, %s) ON CONFLICT (key) DO UPDATE SET value = EXCLUDED.value, updated_at = now()",
+                             (self.key, json.dumps(payload, default=str)))
         except Exception:
             log.debug("replay status write failed", exc_info=True)
 
@@ -292,8 +317,7 @@ def main(stop_event: threading.Event | None = None) -> None:
             t0 = time.time()
             try:
                 trades, events, n = parse_hour(tmp)
-                day = config.REPLAY_DIR / f"{h:%Y-%m-%d}"; day.mkdir(parents=True, exist_ok=True)
-                pq.write_table(trades, day / f"{h:%H}_trades.parquet", compression="zstd"); pq.write_table(events, day / f"{h:%H}_events.parquet", compression="zstd")
+                write_hour(config.REPLAY_DIR / f"{h:%Y-%m-%d}", h, trades, events)
                 tmp.unlink()
                 _db_retry(stop, "replay_hours write", _put_hour,
                           "INSERT INTO replay_hours (hour, status, trades, events, bytes, took_s) VALUES (%s,'done',%s,%s,%s,%s) "
@@ -313,3 +337,137 @@ def main(stop_event: threading.Event | None = None) -> None:
         status.update(stage="stopped", force=True)
         record_event("info", "replay", "replay ingest stopped", {k: status.s.get(k) for k in ("hours_done", "hours_total", "trades", "events", "bytes", "errors")})
         log.info("replay ingest stopped")
+
+
+# ---------------------------------------------------------------- downloading the archive again (fly-trader refetch-archive)
+def refetch_plan(now: datetime | None = None) -> list[datetime]:
+    """Hours whose trades file is stamped otherwise than ``TRADES_VERSION`` (written before the files kept every venue's SOL
+    legs), newest first, leaving the newest ``REFETCH_SKIP_RECENT_H`` hours to the console's replay worker."""
+    now = now or datetime.now(timezone.utc)
+    cut = now - timedelta(hours=config.REFETCH_SKIP_RECENT_H)
+    out = []
+    for f in config.REPLAY_DIR.glob("*/*_trades.parquet"):
+        try:
+            d = datetime.fromisoformat(f.parent.name)
+            h = datetime(d.year, d.month, d.day, int(f.name[:2]), tzinfo=timezone.utc)
+        except ValueError:
+            continue
+        if h < cut and trades_version(f) != TRADES_VERSION:
+            out.append(h)
+    return sorted(out, reverse=True)
+
+
+def live_ok() -> tuple[bool, str]:
+    """The live stream keeps up: its status is fresh and its newest event is at most ``REFETCH_MAX_LAG_S`` behind the
+    status write. A refetch download competes with it for this machine's connection, so none starts while it lags."""
+    try:
+        with transaction() as conn:
+            r = conn.execute("SELECT value, updated_at FROM ui_settings WHERE key = 'pumpstream_status'").fetchone()
+    except Exception as e:
+        return False, f"status unreadable ({e})"
+    if not r:
+        return False, "no stream status"
+    v = r["value"] if isinstance(r["value"], dict) else json.loads(r["value"] or "{}")
+    upd = r["updated_at"]; age = (datetime.now(timezone.utc) - upd).total_seconds()
+    if age > 60:
+        return False, f"stream status {age:.0f} s old"
+    wm = v.get("event_watermark")
+    if not wm:
+        return False, "no stream watermark"
+    lag = (upd - datetime.fromisoformat(wm)).total_seconds()
+    return (lag <= config.REFETCH_MAX_LAG_S, f"stream {lag:.0f} s behind")
+
+
+def refetch_main(stop_event: threading.Event | None = None) -> dict:
+    """Download again every hour ``refetch_plan`` lists, ``REFETCH_PARALLEL`` at a time, in this process (run it apart from
+    the console, at low priority: ``nice -n 19 fly-trader refetch-archive``). Each hour is parsed and written as the replay
+    worker would (``write_hour``); a download starts only while the live stream keeps up (``live_ok``). When a day's hours
+    are all rewritten its aggregate is stale (train/mature.agg_stale: inputs newer) and a build round is tried here, never
+    waiting behind another process's round. Status: ``ui_settings['replay_refetch_status']``."""
+    setup("replay_refetch"); stop = stop_event or threading.Event()
+    hours = refetch_plan(); status = _Status(len(hours), "replay_refetch_status"); status.update(stage="refetching", force=True)
+    by_day: dict = {}
+    for h in hours:
+        by_day.setdefault(h.date(), set()).add(h)
+    log.info("archive refetch: %d hours on %d days to download again (%d at a time)", len(hours), len(by_day), config.REFETCH_PARALLEL)
+    tmpdir = config.REPLAY_DIR / "_refetch_tmp"; tmpdir.mkdir(parents=True, exist_ok=True)
+    for f in tmpdir.glob("*"):
+        f.unlink()
+    todo: queue.Queue = queue.Queue(); ready: queue.Queue = queue.Queue(maxsize=config.REFETCH_PARALLEL + 1)
+    for h in hours:
+        todo.put(h)
+    client = httpx.Client(headers={"User-Agent": "fly-trader replay refetch"}, timeout=httpx.Timeout(60.0, read=600.0), follow_redirects=True)
+    paused = {"why": None}
+
+    def downloader():
+        while not stop.is_set():
+            ok, why = live_ok()
+            if not ok:
+                if paused["why"] is None:
+                    log.info("refetch paused: %s", why)
+                paused["why"] = why; status.update(paused=why); stop.wait(30.0); continue
+            if paused["why"] is not None:
+                log.info("refetch resumed"); paused["why"] = None; status.update(paused=None)
+            try:
+                h = todo.get_nowait()
+            except queue.Empty:
+                return
+            tmp = tmpdir / f"{h:%Y%m%d%H}.zst"
+            for attempt in range(4):
+                try:
+                    t0 = time.time(); size = _download(client, h, tmp, stop)
+                    ready.put((h, tmp, size, time.time() - t0)); break
+                except InterruptedError:
+                    return
+                except Exception as e:
+                    log.warning("refetch download %s failed (%d): %s", h, attempt, e); stop.wait(10 * (attempt + 1))
+            else:
+                ready.put((h, None, 0, 0.0))
+
+    threads = [threading.Thread(target=downloader, name=f"replay_refetch-dl-{i}", daemon=True) for i in range(config.REFETCH_PARALLEL)]
+    for t in threads:
+        t.start()
+    from ..train import mature
+    rebuild: dict = {"thread": None}
+    done = failed = 0
+    try:
+        while not stop.is_set() and (any(t.is_alive() for t in threads) or not ready.empty()):
+            try:
+                h, tmp, size, dl_s = ready.get(timeout=5.0)
+            except queue.Empty:
+                continue
+            if tmp is None or size < 0:
+                failed += 1; status.update(errors=failed)
+                log.warning("refetch %s: %s; the hour keeps its old file", h, "not in the archive" if size < 0 else "download failed")
+            else:
+                t0 = time.time()
+                try:
+                    trades, events, n = parse_hour(tmp)
+                    write_hour(config.REPLAY_DIR / f"{h:%Y-%m-%d}", h, trades, events)
+                    done += 1
+                    status.update(hours_done=done, bytes=status.s["bytes"] + size, last_hour=h.isoformat(), last_parse_s=round(time.time() - t0, 1), last_dl_s=round(dl_s, 1))
+                    log.info("refetched %s: %d events -> %d trade rows (%.0f MB, dl %.0fs, parse %.1fs)", h.isoformat(), n, trades.num_rows, size / 1e6, dl_s, time.time() - t0)
+                except Exception:
+                    failed += 1; status.update(errors=failed); log.exception("refetch parse %s failed; the hour keeps its old file", h)
+                finally:
+                    tmp.unlink(missing_ok=True)
+            day = by_day.get(h.date())
+            if day is not None:
+                day.discard(h)
+                if not day:                                  # the day is rewritten: rebuild it here (one round at a time)
+                    del by_day[h.date()]
+                    if rebuild["thread"] is None or not rebuild["thread"].is_alive():
+                        def _round(d=h.date()):
+                            try:
+                                n = mature.try_loop_once()
+                                log.info("refetch: build round after %s: %s", d, "another process holds the build" if n is None else f"{n} day steps")
+                            except Exception:
+                                log.exception("refetch: build round after %s failed (the console's round rebuilds it)", d)
+                        rebuild["thread"] = threading.Thread(target=_round, name="replay_refetch-build", daemon=True); rebuild["thread"].start()
+    finally:
+        stop.set()
+        if rebuild["thread"] is not None:
+            rebuild["thread"].join()                     # its day's files are written atomically either way
+        status.update(stage="stopped", force=True)
+        log.info("archive refetch stopped: %d hours rewritten, %d failed, %d planned", done, failed, len(hours))
+    return {"planned": len(hours), "done": done, "failed": failed}

fly_trader/kalshi/strategies.py

@@ -91,8 +91,12 @@ def oos(ds, rows: np.ndarray, y: np.ndarray, ci: np.ndarray, H, stop, label_: st
 
 
 def fit_final(ds, rows: np.ndarray, ci: np.ndarray, H):
-    """The deployed model of a strategy: a classifier of the side paying, on its candidate rows (at most ds.train_max_rows)."""
-    rows = S.cap_rows(ds, np.flatnonzero(rows), 99)
+    """The deployed model of a strategy: a classifier of the side paying, on its candidate rows (at most ds.train_max_rows).
+    ``rows``: row indices, as train/strategies.final_models passes them (a boolean mask is accepted too). From 2026-10-07
+    to 2026-10-12 this took the indices through np.flatnonzero a second time, which turned them into 0..n−1: every final
+    and holdout model (selectors 188, 220, 249) trained on the corpus's first n rows instead of the strategy's own."""
+    rows = np.asarray(rows)
+    rows = S.cap_rows(ds, np.flatnonzero(rows) if rows.dtype == bool else rows, 99)
     scaler = RobustScaler.fit(ds.X[np.ix_(rows, ci)], seed=99)
     m = HistGradientBoostingClassifier(**S._gbm_params(), random_state=99); m.fit(scaler.transform(ds.X[np.ix_(rows, ci)]), ds.outcome[rows].astype(np.int8))
     return m, scaler

fly_trader/ops/release.py

@@ -102,7 +102,7 @@ def apply_release(release_dir: Path, bootstrap: bool = False) -> dict:
     if not ok:
         raise ReleaseError(f"the release's fly is not deployable on this code: {why}")
     v = seed["verdict"]
-    if not v.get("passed") or v.get("data") != fly_selector.verdict_version():
+    if not v.get("passed") or not fly_selector.selector.defs_match(v.get("data"), fly_selector.verdict_version()):
         raise ReleaseError("the release's replay verdict did not pass on this code's definitions")
     ids: dict[str, int] = {}
     with transaction() as conn:

fly_trader/rh/corpus.py

@@ -9,10 +9,15 @@
 4. ``rh/wallet_skill.build_wallet_day(D − 1)`` once D's aggregate and part exist.
 
 A day is built once complete (the minutes cursor past its end); a part records ``fly_chain = rh`` and ``fly_rh_agg``.
+The stream builds no day itself: once one is due it starts ``fly-trader rh-build-corpus`` (``run_locked``) as a child
+process at the lowest CPU priority. A day took ~30 s in the stream's thread at 00:00 UTC on 2026-10-23, in front of the
+next minute's write, and the other v4 pools (rh/v4_universe.py) add several times the swaps.
 """
 from __future__ import annotations
 
+import fcntl
 import logging
+import time
 from datetime import date, datetime, timedelta, timezone
 
 import pyarrow as pa
@@ -48,19 +53,29 @@ def aggregate(d: date) -> int:
 
 
 def _meta_extra() -> tuple[dict, dict, dict]:
-    """(graduations, supplies, TokenMeta extras) for every graduated launch."""
+    """(graduations, supplies, TokenMeta extras) for every graduated launch. Its fee medians read all of rh_minutes (13 s on
+    2026-10-23): ``run_once`` reads it once a run, in the middle of a minute (``_quiet``)."""
     k = config.RH_ETH_PER_SOL
     with transaction() as conn:
-        g = conn.execute("SELECT mint, graduated_at FROM rh_meta").fetchall()
+        g = conn.execute("SELECT mint, graduated_at, supply FROM rh_meta").fetchall()
         fees = conn.execute("SELECT mint, percentile_cont(0.5) WITHIN GROUP (ORDER BY fee_rate) AS f FROM rh_minutes WHERE fee_rate IS NOT NULL GROUP BY mint").fetchall()
     grads = {r["mint"]: r["graduated_at"] for r in g}
     fee = {r["mint"]: float(r["f"]) for r in fees}
     extra = {m: {"ec_size": 0.1 * k, "pool_fee": fee.get(m, config.RH_HOOK_FEE)} for m in grads}
-    return grads, {m: 1e9 for m in grads}, extra
+    return grads, {r["mint"]: float(r["supply"]) if r["supply"] else 1e9 for r in g}, extra     # a plain v4 memecoin's own supply
 
 
-def build_day(d: date) -> int:
-    grads, supplies, extra = _meta_extra()
+def _quiet() -> None:
+    """Wait for the middle of a minute (agent/live_first.MID_MINUTE) before a long read of the database: the live
+    pipeline's reads run in the first seconds after a minute's end."""
+    from ..agent import live_first
+    while not live_first.mid_minute():
+        time.sleep(1.0)
+
+
+def build_day(d: date, meta: tuple | None = None) -> int:
+    """Day ``d``'s feature rows; ``meta``: ``_meta_extra()``'s result, read here when not given."""
+    grads, supplies, extra = meta if meta is not None else _meta_extra()
     return mature.build_day(d, grads=grads, supplies=supplies, src_dir=MATURE_DIR, out_dir=FEAT_DIR, program_label=PONS_LABEL, meta_extra=extra,
                             extra_md={"fly_chain": "rh", "fly_rh_agg": RH_AGG_VERSION})
 
@@ -86,14 +101,42 @@ def run_once(max_days: int = 3) -> dict:
     last = complete_through()
     if last is None:
         return {"days": 0}
-    d = date.fromisoformat(config.RH_START_DAY); done = 0; out = {}
+    d = date.fromisoformat(config.RH_START_DAY); done = 0; out = {}; meta = None
     while d <= last and done < max_days:
         part = FEAT_DIR / d.isoformat() / "part.parquet"; agg = MATURE_DIR / f"{d.isoformat()}.parquet"
         if not agg.exists() or not part_current(part):
             wallet_skill.write_table(d)
             n_agg = aggregate(d)
-            n_part = build_day(d) if n_agg else 0
+            if n_agg and meta is None:
+                _quiet(); meta = _meta_extra()        # once a run, not once a day
+            n_part = build_day(d, meta) if n_agg else 0
             wallet_skill.build_wallet_day(d - timedelta(days=1))
             out[d.isoformat()] = {"minutes": n_agg, "rows": n_part}; done += 1
         d += timedelta(days=1)
     return {"days": done, "built": out}
+
+
+def due(days: int = 3) -> bool:
+    """Whether one of the last ``days`` complete days lacks its corpus files (``run_once`` would build it)."""
+    last = complete_through()
+    if last is None:
+        return False
+    first = date.fromisoformat(config.RH_START_DAY)
+    for i in range(days):
+        d = last - timedelta(days=i)
+        if d < first:
+            break
+        if not (MATURE_DIR / f"{d.isoformat()}.parquet").exists() or not part_current(FEAT_DIR / d.isoformat() / "part.parquet"):
+            return True
+    return False
+
+
+def run_locked(max_days: int = 3) -> dict:
+    """``run_once`` under a file lock, one builder at a time across processes (``fly-trader rh-build-corpus``)."""
+    MATURE_DIR.mkdir(parents=True, exist_ok=True)
+    with open(MATURE_DIR / ".rh_build.lock", "w") as lock:
+        try:
+            fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB)
+        except BlockingIOError:
+            return {"days": 0, "busy": True}
+        return run_once(max_days)

fly_trader/rh/index.py

@@ -7,8 +7,10 @@ Per block range, in order:
 2. those events applied in (block, log index) order → rh_tokens, rh_pools, rh_insiders; a graduation also pulls that
    launch's curve trades from its own curve contract (launch → graduation, address-filtered): only the ~1 % of launches
    that graduate are ever traded, and their curve phase is all the features need (curve facts, time to graduate);
-3. the v4 PoolManager's Initialize / Swap / ModifyLiquidity logs for the Pons pools known by then (topic1 = pool id,
-   200 ids per request), each swap matched to its hook fee by (tx, pool) in log order;
+3. the v4 PoolManager's Initialize / Swap / ModifyLiquidity logs for the Pons pools known by then and the other v4 pools
+   indexed since 2026-10-23 (rh/v4_universe.py: a Pons coin's own pools elsewhere, plain v4 memecoins; topic1 = pool id,
+   200 ids per request), each Pons swap matched to its hook fee by (tx, pool) in log order, another pool's swap priced at
+   the LP fee its Swap event reports;
 4. each swap's trader from the memecoin's own Transfer logs in that transaction (address-filtered, one request per 200
    tokens): the wallet whose token balance rose on a buy (fell on a sell), not the pool manager or a router — the swap
    event itself names the router (measured 2026-09-28: per-swap tx lookups made a 55-day backfill take ~43 days);
@@ -196,11 +198,13 @@ def apply_pons(conn, rpc, events: list[dict]) -> dict:
     return n
 
 
-def apply_v4(conn, rpc, logs: list[dict], fees: list[dict]) -> dict:
-    """v4 logs of Pons pools (+ their hook fees) → rh_swaps / rh_liquidity / rh_pools state."""
+def apply_v4(conn, rpc, logs: list[dict], fees: list[dict], pool_ids: list[str] | None = None) -> dict:
+    """v4 logs of the indexed pools (Pons pools + their hook fees, and the other indexed v4 pools) → rh_swaps / rh_liquidity /
+    rh_pools state. ``pool_ids``: exactly these pools (a live pool's history before its ``live_from``: rh/v4_universe)."""
+    sel = "p.pool_id = ANY(%s)" if pool_ids is not None else "(p.is_pons OR p.indexed)"
     pools = {r["pool_id"]: dict(r) for r in conn.execute(
-        "SELECT p.pool_id, p.token, p.token_is_0, p.quote_asset, p.hook_fee, p.hook_fee_v, a.decimals AS qdec FROM rh_pools p JOIN rh_assets a ON a.asset = p.quote_asset "
-        "WHERE p.is_pons").fetchall()}
+        "SELECT p.pool_id, p.token, p.token_is_0, p.quote_asset, p.hook_fee, p.hook_fee_v, p.is_pons, a.decimals AS qdec FROM rh_pools p JOIN rh_assets a ON a.asset = p.quote_asset "
+        "WHERE " + sel, (list(pool_ids),) if pool_ids is not None else ()).fetchall()}
     fee_q: dict[tuple, list] = {}; observed: dict[str, int] = {}
     for f in fees:
         fee_q.setdefault((f["tx_hash"], f["pool_id"]), []).append(f)
@@ -225,9 +229,10 @@ def apply_v4(conn, rpc, logs: list[dict], fees: list[dict]) -> dict:
         if e is None or e["pool_id"] not in pools:
             continue
         p = pools[e["pool_id"]]
-        if e["event"] == "Initialize":
-            conn.execute("UPDATE rh_pools SET sqrt_price_x96 = %s, tick = %s, fee = %s, tick_spacing = %s, hooks = %s, updated_block = %s WHERE pool_id = %s",
-                         (e["sqrt_price_x96"], e["tick"], e["fee"], e["tick_spacing"], e["hooks"], e["block"], e["pool_id"]))
+        if e["event"] == "Initialize":                                     # (a history backfill never rolls a live pool's state back)
+            conn.execute("UPDATE rh_pools SET sqrt_price_x96 = %s, tick = %s, fee = %s, tick_spacing = %s, hooks = %s, updated_block = %s WHERE pool_id = %s "
+                         "AND (updated_block IS NULL OR updated_block <= %s)",
+                         (e["sqrt_price_x96"], e["tick"], e["fee"], e["tick_spacing"], e["hooks"], e["block"], e["pool_id"], e["block"]))
         elif e["event"] == "ModifyLiquidity":
             conn.execute("INSERT INTO rh_liquidity (block, log_index, tx_hash, ts, pool_id, sender, tick_lower, tick_upper, liquidity_delta, salt) "
                          "VALUES (%s, %s, %s, to_timestamp(%s), %s, %s, %s, %s, %s, %s) ON CONFLICT DO NOTHING",
@@ -239,9 +244,11 @@ def apply_v4(conn, rpc, logs: list[dict], fees: list[dict]) -> dict:
             side = 1 if tok_amt > 0 else -1                                   # the swapper received tokens: a buy
             fq = fee_q.get((e["tx_hash"], e["pool_id"])) or []
             fee = fq.pop(0) if fq else None
-            price_q = v4.token_price_in_quote(e["sqrt_price_x96"], ti0, PONS_DECIMALS, qdec)
+            price_q = v4.token_price_in_quote(e["sqrt_price_x96"], ti0, PONS_DECIMALS, qdec)       # 18 decimals: rh/token_check admits no other
             fee_frac = None
-            if fee:
+            if not p["is_pons"]:
+                fee_frac = float(e.get("fee") or 0) / 1e6; fee_v = 2                             # the swap's LP fee (hundredths of a bip)
+            elif fee:
                 # the hook takes fee + tax out of the pool's gross output, which is the Swap event's amount of that currency:
                 # the swapper receives (1 − r) of it (live fills receive exactly that), so r = taken / gross. Until 2026-10-17
                 # this stored taken / (gross + taken), 0.0099 for a 1 % fee: those rows have fee_v NULL and readers convert them.
@@ -267,8 +274,8 @@ def apply_v4(conn, rpc, logs: list[dict], fees: list[dict]) -> dict:
             conn.execute(f"UPDATE rh_pools SET hook_fee = (SELECT percentile_cont(0.5) WITHIN GROUP (ORDER BY {FEE_FRAC}) FROM rh_swaps "
                          "WHERE pool_id = %s AND hook_fee_raw IS NOT NULL AND fee_frac IS NOT NULL), hook_fee_v = 2 WHERE pool_id = %s", (pid, pid))
     for pid, e in last_state.items():
-        conn.execute("UPDATE rh_pools SET sqrt_price_x96 = %s, liquidity = %s, tick = %s, updated_block = %s WHERE pool_id = %s",
-                     (e["sqrt_price_x96"], e["liquidity"], e["tick"], e["block"], pid))
+        conn.execute("UPDATE rh_pools SET sqrt_price_x96 = %s, liquidity = %s, tick = %s, updated_block = %s WHERE pool_id = %s "
+                     "AND (updated_block IS NULL OR updated_block <= %s)", (e["sqrt_price_x96"], e["liquidity"], e["tick"], e["block"], pid, e["block"]))
     return n
 
 
@@ -281,11 +288,11 @@ def step(conn, rpc, lo: int, hi: int) -> dict:
     evs = [e for e in evs if e is not None]
     fill_timestamps(rpc, evs, lo, hi)
     n = apply_pons(conn, rpc, evs)
-    ids = [r["pool_id"] for r in conn.execute("SELECT pool_id FROM rh_pools WHERE is_pons ORDER BY pool_id").fetchall()]
+    ids = [r["pool_id"] for r in conn.execute("SELECT pool_id FROM rh_pools WHERE is_pons OR indexed ORDER BY pool_id").fetchall()]
     need = [r["pool_id"] for r in conn.execute("SELECT pool_id FROM rh_pools WHERE is_pons AND hook_fee IS NULL ORDER BY pool_id").fetchall()]
     fee_topic = [FEE_TOPIC]
     v4_logs, fee_logs = [], []
-    if bulk and hi - lo + 1 <= LIVE_SPAN_BULK:                     # a live range: every PoolManager event, matched to Pons pools here
+    if bulk and hi - lo + 1 <= LIVE_SPAN_BULK:                     # a live range: every PoolManager event, matched to the indexed pools here
         mine = set(ids)                                             # (10k+ pool ids make a ~0.7 MB filter; HyperSync caps bodies at 2 MB)
         v4_logs = [g for g in _get_logs(rpc, [config.V4_POOL_MANAGER], lo, hi, [topics0]) if len(g["topics"]) > 1 and g["topics"][1].lower() in mine]
     else:

fly_trader/rh/live.py

@@ -89,12 +89,17 @@ class RhLiveMirror:
         self.last_mark: dict | None = None
         self.last_reconciled: dict | None = None
         self.wallet_eth: float | None = None
+        self.sale_waits: dict[int, list] = {}   # decision id -> [Event, result]: an operator's Sell Now waiting for its sale (``sell_now``)
         self.ex.on_done = self._after_order
 
     @property
     def wallet(self):
         return self.ex.wallet
 
+    def read_balance(self) -> int:
+        """The wallet's ETH (wei); started beside the minute's scoring by live_first.prefetch."""
+        return int(self.wallet.balance())
+
     def _decision(self, conn, m1, run_id, beat_id, p, reason: str, forced: bool) -> int:
         return int(conn.execute("INSERT INTO decisions (beat_id, run_id, ts, mint, pool, kind, size_sol, forced, reason, detail) VALUES (%s,%s,%s,%s,%s,'fly_exit',%s,%s,%s,%s) RETURNING id",
                                 (beat_id, run_id, m1, p["mint"], p["pool"], float(p["cost_sol"]), forced, reason, json.dumps({"book": BOOK}))).fetchone()["id"])
@@ -172,11 +177,39 @@ class RhLiveMirror:
             record_event("error", "rh_live", f"kill switch: liquidating {n_liq} open live RH position(s)", {"positions": n_liq})
         return {"exited": n_exit, "liquidated": n_liq}
 
-    def minute(self, ctx, *, run_id: str, beat_id: int, entries: list) -> dict:
+    def sell_now(self, conn, position_id: int) -> int:
+        """The operator's Sell Now (the console's open positions, agent/live_first.sell_now): one open position of this book
+        sold at once, at the exit's slippage stepping up to the forced one, and booked by the executor like any exit, as a
+        forced 'operator' exit (the live-vs-paper gap and the fly's fill pathway leave it out). Its decision id; ValueError
+        with the reason when nothing was sent (the caller's transaction then rolls its decision back)."""
+        with self.exit_lock:                     # the clock's boundary sales check the same in-flight set: one sale per position
+            p = next((p for p in ledger.open_positions(conn, BOOK) if int(p["id"]) == int(position_id)), None)
+            if p is None:
+                raise ValueError("this position is no longer open")
+            if p["mint"].lower() in self.ex.pending():
+                raise ValueError("an order of this token is already queued or in flight")
+            did = self._decision(conn, datetime.now(timezone.utc), None, None, p, "sold now by the operator", True)
+            self.sale_waits[did] = [threading.Event(), None]
+            if not self._sell(conn, p, did, config.SLIPPAGE_EXIT_BPS, "operator"):
+                self.sale_waits.pop(did, None)
+                raise ValueError("an order of this token is already queued or in flight")
+        return did
+
+    def sale_result(self, did: int, timeout: float):
+        """The executor's result of a ``sell_now`` sale once booked, waiting at most ``timeout`` s (None: not yet)."""
+        w = self.sale_waits.get(did)
+        if w is None:
+            return None
+        w[0].wait(timeout)
+        self.sale_waits.pop(did, None)
+        return w[1]
+
+    def minute(self, ctx, *, run_id: str, beat_id: int, entries: list, rebuy: dict | None = None) -> dict:
         """The minute's entries, sent the moment the fly has decided (agent/fly_session.FlyBook.on_minute): the executor's
         results first (a failed buy is kept for another try), the minute's sales if the clock has not sent them, then the
-        retries and the paper entries. The wallet is read only when there is something to buy; the wealth mark waits for
-        ``idle``."""
+        retries and the paper entries. A retry goes out only where this minute would buy its token again (``rebuy``,
+        agent/paper_trading.plan_minute), on this minute's score and against this minute's price, never its decision's.
+        The wallet is read only when there is something to buy; the wealth mark waits for ``idle``."""
         conn, m1 = ctx.conn, ctx.m1
         drained = self.ex.drain()
         for r in drained:
@@ -191,7 +224,7 @@ class RhLiveMirror:
         blocked = "kill switch" if c.kill_switch else "circuit tripped" if rails.breaker_blocks(c) else "paused" if c.entries_paused else None
         n_enter = n_retry = 0; skipped = []
         if self.failed or entries:
-            reserved = reserved_wei(conn); native_eth = self.wallet.balance() / A.WEI; self.wallet_eth = native_eth
+            reserved = reserved_wei(conn); native_eth = live_first.take_balance(self, ctx.m1_epoch) / A.WEI; self.wallet_eth = native_eth
             committed = self.ex.committed_wei() / A.WEI
             bankroll = native_eth + sum(float(p["cost_sol"]) for p in opens if not self._dead(p, m1)) - reserved / A.WEI   # not a dead-bag ``after`` writes off
             cash = native_eth - reserved / A.WEI - committed
@@ -201,14 +234,18 @@ class RhLiveMirror:
                 if over:
                     self.failed.pop(did); skipped.append((mint, "retries exhausted"))
                     self._blocked(conn, ctx, run_id, beat_id, e, "retries exhausted", f"{over}; last error: {(f.get('error') or '')[:200]}", tries=f["tries"]); continue
+                v = (rebuy or {}).get(e["mint"]) or {"why": "not scored this minute"}       # this minute's verdict on buying it again
+                e = {**e, **{k: v[k] for k in ("score", "threshold", "table", "ref_price") if k in v}}   # its score and price now, not its decision's
                 pool = pool_of(conn, e["info"].get("pool")); quote = ((pool or {}).get("quote_asset") or ZERO).lower()
-                rail = blocked or ("stale minute" if stale else None) or ("held" if mint in held_mints else None) or ("base mark stale" if A.base_mark(conn, quote)[1] else None)
+                rail = (blocked or ("stale minute" if stale else None) or ("held" if mint in held_mints else None) or (None if "ref_price" in v else "no longer a buy")
+                        or ("base mark stale" if A.base_mark(conn, quote)[1] else None))
                 size, why = (0.0, "") if rail else sizing.size_position(e["score"], e.get("threshold", 0.0), e.get("table") or [], bankroll, cash,
                                                                         ctx.resqs.get(e["mint"]) or e["info"]["resq"], flat=config.FLY_SIZING == "flat", market=RH)
                 if rail or size <= 0:
-                    skipped.append((mint, rail or why)); self._blocked(conn, ctx, run_id, beat_id, e, rail or "sizing", f"retry not sent: {rail or why}", size, retry=True); continue
+                    why = v["why"] if rail == "no longer a buy" else rail or why
+                    skipped.append((mint, why)); self._blocked(conn, ctx, run_id, beat_id, e, rail or "sizing", f"retry not sent: {why}", size, retry=True); continue
                 if self._buy(e, mint, quote, pool, size, retry=f["tries"]):
-                    self.failed.pop(did); self.sent[did] = {**f, "tries": f["tries"] + 1}
+                    self.failed.pop(did); self.sent[did] = {**f, "e": e, "tries": f["tries"] + 1}
                     n_enter += 1; n_retry += 1; cash -= size; held_mints.add(mint)
             for e in entries:
                 mint = e["mint"].lower()
@@ -276,6 +313,9 @@ class RhLiveMirror:
             except Exception:
                 log.warning("live rh mark after an intent failed", exc_info=True)
         live_first.changed()
+        w = self.sale_waits.get(res.request.decision_id) if res is not None else None
+        if w is not None:                        # an operator's Sell Now waiting for this sale (``sell_now``)
+            w[1] = res; w[0].set()
 
     def mark_due(self, conn=None, force: bool = False) -> dict | None:
         """The waiting minute's wealth mark (rh/accounting.wealth at the minute's prices) and circuit 3's kill switch on the
@@ -329,8 +369,9 @@ class RhLiveMirror:
     def gap(self, conn) -> dict:
         rows = conn.execute("""SELECT l.realized_sol / NULLIF(l.cost_sol, 0) AS rl, p.realized_sol / NULLIF(p.cost_sol, 0) AS rp
                                FROM positions l JOIN positions p ON p.entry_decision_id = l.entry_decision_id AND p.book = %s AND p.status = 'closed'
-                               WHERE l.book = %s AND l.status = 'closed' AND l.entry_decision_id IS NOT NULL ORDER BY l.closed_at DESC LIMIT %s""",
-                            (MIRROR, BOOK, GAP_TRADES)).fetchall()
+                               WHERE l.book = %s AND l.status = 'closed' AND l.entry_decision_id IS NOT NULL AND COALESCE(l.forced_exit_kind, '') <> 'operator'
+                               ORDER BY l.closed_at DESC LIMIT %s""",
+                            (MIRROR, BOOK, GAP_TRADES)).fetchall()             # an operator's Sell Now is the operator's choice, not an execution gap
         pairs = [(r["rl"], r["rp"]) for r in rows if r["rl"] is not None and r["rp"] is not None]
         rl = np.array([a for a, _ in pairs], dtype=np.float64); rp = np.array([b for _, b in pairs], dtype=np.float64)
         out = {"trades": int(len(rl)), "live_mean": float(rl.mean()) if len(rl) else None, "mirror_mean": float(rp.mean()) if len(rp) else None}

fly_trader/rh/meta.py

@@ -86,6 +86,47 @@ def outcomes(conn, token: str, graduated_at) -> tuple[float, float] | None:
 COLS = ("mint", "graduated_at", "create_ts", "creator", "quote_asset", "quote_class", "supply", "ttg_min", "dev_sol", "dev_tokens", "dev_share", "mayhem", "rq0",
         "pool_id", "prior_launches", "prior_grads", "prior_known", "prior_rug_share", "prior_moon_share", "bundle_share", "dev_hold_share", "dev_sold_frac",
         "grad_hhi", "curve_known")
+V4_COLS = COLS + ("source",)
+
+
+def _history(conn, creator: str | None, since, g, mint: str) -> dict:
+    """A creator's earlier launches (Pons and plain v4) and graduations with their first-hour outcomes, as ``build``."""
+    if not creator:
+        return {"prior_launches": None, "prior_grads": None, "prior_known": None, "prior_rug_share": None, "prior_moon_share": None}
+    n = conn.execute("SELECT (SELECT count(*) FROM rh_tokens WHERE creator = %(c)s AND launch_ts < %(t)s) + "
+                     "(SELECT count(*) FROM rh_v4_tokens WHERE creator = %(c)s AND first_ts < %(t)s) AS n", {"c": creator, "t": since}).fetchone()["n"]
+    r = conn.execute("""SELECT count(*) AS grads,
+                               count(*) FILTER (WHERE own_dd60 IS NOT NULL AND graduated_at + interval '60 minutes' <= %(g)s) AS known,
+                               avg(CASE WHEN own_dd60 <= -0.9 THEN 1.0 ELSE 0.0 END) FILTER (WHERE own_dd60 IS NOT NULL AND graduated_at + interval '60 minutes' <= %(g)s) AS rug,
+                               avg(CASE WHEN own_max60 >= 1.0 THEN 1.0 ELSE 0.0 END) FILTER (WHERE own_dd60 IS NOT NULL AND graduated_at + interval '60 minutes' <= %(g)s) AS moon
+                        FROM rh_meta WHERE creator = %(c)s AND graduated_at < %(g)s AND mint <> %(m)s""", {"c": creator, "g": g, "m": mint}).fetchone()
+    return {"prior_launches": int(n), "prior_grads": int(r["grads"]), "prior_known": int(r["known"]),
+            "prior_rug_share": float(r["rug"]) if r["rug"] is not None else None, "prior_moon_share": float(r["moon"]) if r["moon"] is not None else None}
+
+
+def build_v4(conn, token: str) -> dict | None:
+    """rh_meta facts of a plain v4 memecoin that passed its contract check (rh/v4_universe.py): its age counts from its
+    first pool's initialization (``graduated_at``: the 6 h floor), its creator is that pool's initializer, and what only a
+    Pons launch records (curve, dev buy, seed reserve, time to graduate) is unknown, as for a Solana coin graduated before
+    the archive. Supply in whole tokens (18 decimals)."""
+    t = conn.execute("SELECT v.*, a.class AS qclass FROM rh_v4_tokens v LEFT JOIN rh_assets a ON a.asset = v.quote_asset WHERE v.token = %s AND v.status = 'ok'",
+                     (token,)).fetchone()
+    if not t or t["first_ts"] is None:
+        return None
+    g = t["first_ts"]
+    return {"mint": token, "graduated_at": g, "create_ts": g, "creator": t["creator"], "quote_asset": t["quote_asset"], "quote_class": t["qclass"] or "eth",
+            "supply": float(t["supply_raw"]) / TOKEN if t["supply_raw"] is not None else None, "ttg_min": None, "dev_sol": None, "dev_tokens": None,
+            "dev_share": None, "mayhem": False, "rq0": None, "pool_id": t["first_pool"], **_history(conn, t["creator"], g, g, token),
+            "bundle_share": None, "dev_hold_share": None, "dev_sold_frac": None, "grad_hhi": None, "curve_known": 0.0, "source": "v4"}
+
+
+def write_v4(conn, token: str) -> bool:
+    """``build_v4`` into rh_meta (idempotent); False when the coin has no accepted row."""
+    row = build_v4(conn, token)
+    if row is None:
+        return False
+    conn.execute(f"INSERT INTO rh_meta ({', '.join(V4_COLS)}) VALUES ({', '.join(['%s'] * len(V4_COLS))}) ON CONFLICT (mint) DO NOTHING", [row.get(k) for k in V4_COLS])
+    return True
 
 
 def run_once(limit: int = 500) -> dict:
@@ -101,8 +142,8 @@ def run_once(limit: int = 500) -> dict:
                 continue
             conn.execute(f"INSERT INTO rh_meta ({', '.join(COLS)}) VALUES ({', '.join(['%s'] * len(COLS))}) ON CONFLICT (mint) DO NOTHING", [row.get(k) for k in COLS])
             n_new += 1
-        due = conn.execute("SELECT m.mint, m.graduated_at FROM rh_meta m WHERE m.own_dd60 IS NULL AND m.graduated_at + interval '61 minutes' <= "
-                           "(SELECT max(ts) FROM rh_minutes) LIMIT %s", (limit,)).fetchall()
+        due = conn.execute("SELECT m.mint, m.graduated_at FROM rh_meta m WHERE m.own_dd60 IS NULL AND m.source = 'pons' AND m.graduated_at + interval '61 minutes' <= "
+                           "(SELECT max(ts) FROM rh_minutes) LIMIT %s", (limit,)).fetchall()      # a plain v4 coin's: rh/v4_universe.backfill_history
         for r in due:
             o = outcomes(conn, r["mint"], r["graduated_at"])
             if o is not None:

fly_trader/rh/minutes.py

@@ -2,15 +2,22 @@
 
 The same rules as the Solana stream (ingest/pumpstream.Aggregator) and the archive (train/mature.aggregate_table):
 - a swap counts only while its pool's reserve is plausible (``RESQ_BAND`` scaled by K = ETH per SOL) and its price is
-  within ``PRICE_BAND`` (50×) of the median of the mint's previous ``REF_LEGS`` (200) prices that UTC day;
+  within ``PRICE_BAND`` (50×) of the median of the pool's previous ``REF_LEGS`` (200) prices that UTC day (a Pons coin has
+  one Pons pool: until 2026-10-23 the median was keyed by the mint, the same prices);
 - open/high/low/close = the pool price after each swap (sqrtPriceX96 of the Swap event), in ETH per token: the quote price
   times the quote asset's ETH value that minute (rh/prices.py; ETH-quoted pools: 1). A minute whose non-ETH quote has no
   mark yet is not written (it cannot be expressed in ETH);
 - buy/sell volume in ETH; resq = the pool's virtual quote reserve in ETH (full-range locked liquidity: constant product);
-- fee_rate = the volume-weighted Pons hook fee + tax fraction (the analogue of pump_minutes.fee_rate, the pool fee charged);
+- fee_rate = the volume-weighted Pons hook fee + tax fraction, or another v4 pool's LP fee (the analogue of
+  pump_minutes.fee_rate, the pool fee charged);
+- a coin with several indexed pools (a Pons coin's own pools elsewhere, a plain v4 memecoin's pools: rh/v4_universe.py)
+  takes each minute from the pool with the most swaps, as the Solana stream and archive take the pool with the most legs;
 - the wallet columns (buyers, wash, top seller, insider sells, buys per skill decile) by train/flow.minute_wallet_cols.
 
-Minutes are recomputed from the swaps, never accumulated, so a live pass and a backfill write identical rows.
+Minutes are recomputed from the swaps, never accumulated, so a live pass and a backfill write identical rows. Only the
+median needs swaps before the first minute: each pool's last ``REF_LEGS`` prices that day are read for it (until 2026-10-23
+every swap since 00:00 UTC was re-read for each live minute: ~2.3 s per minute by 23:59, in front of the RH live entries).
+Only the Pons pools and the other v4 pools that went live (``indexed``) count, unless ``tokens`` names the coins.
 """
 from __future__ import annotations
 
@@ -42,9 +49,10 @@ class _Row:
         self.resq_eth = self.resq_q = None; self.fee_w = 0.0; self.fee_v = 0.0
 
 
-def aggregate(conn, t0: int, t1: int, skill: dict | None = None, quote_asset: str | None = None) -> list[tuple]:
+def aggregate(conn, t0: int, t1: int, skill: dict | None = None, quote_asset: str | None = None, tokens: list[str] | None = None) -> list[tuple]:
     """rh_minutes rows for every minute in [t0, t1) (epoch s, minute-aligned). ``quote_asset``: only the pools quoted in
-    it (a repair after that asset's ETH marks changed)."""
+    it (a repair after that asset's ETH marks changed); ``tokens``: only these coins, every pool of theirs indexed so far
+    (a backfill of their history; otherwise only live pools count)."""
     k = config.RH_ETH_PER_SOL; lo_band, hi_band = RESQ_BAND_SOL[0] * k, RESQ_BAND_SOL[1] * k
     day0 = (t0 // 86400) * 86400
     swaps = conn.execute(
@@ -52,24 +60,34 @@ def aggregate(conn, t0: int, t1: int, skill: dict | None = None, quote_asset: st
         "CASE WHEN s.fee_v = 2 OR s.fee_frac IS NULL OR s.fee_frac >= 1 THEN s.fee_frac ELSE s.fee_frac / (1 - s.fee_frac) END AS fee_frac, "   # rh/index.FEE_FRAC
         "p.quote_asset, a.decimals AS qdec, a.class AS cls "
         "FROM rh_swaps s JOIN rh_pools p ON p.pool_id = s.pool_id JOIN rh_assets a ON a.asset = p.quote_asset "
-        "WHERE s.ts >= to_timestamp(%s) AND s.ts < to_timestamp(%s) AND (%s::text IS NULL OR p.quote_asset = %s) ORDER BY s.ts, s.block, s.log_index",
-        (day0, t1, quote_asset, quote_asset)).fetchall()
+        "WHERE s.ts >= to_timestamp(%(t0)s) AND s.ts < to_timestamp(%(t1)s) AND (%(qa)s::text IS NULL OR p.quote_asset = %(qa)s) "
+        "AND (CASE WHEN %(toks)s::text[] IS NULL THEN p.is_pons OR p.indexed ELSE s.token = ANY(%(toks)s::text[]) END) ORDER BY s.ts, s.block, s.log_index",
+        {"t0": t0, "t1": t1, "qa": quote_asset, "toks": tokens}).fetchall()
     insiders: dict[str, frozenset] = {}
     base_cache: dict[tuple, tuple] = {}
-    ref: dict[str, deque] = {}; ref_day = None
+    ref: dict[str, deque] = {}; ref_day = day0 // 86400
+    first_day = sorted({(s["token"], s["pool_id"]) for s in swaps if s["ts"].timestamp() < day0 + 86400})
+    if first_day and t0 > day0:                                    # the median's state at t0: each pool's last prices that day
+        for h in conn.execute(
+                "SELECT u.pool_id, h.price_q FROM unnest(%s::text[], %s::text[]) AS u(token, pool_id) CROSS JOIN LATERAL ("
+                "SELECT s.price_q, s.ts, s.block, s.log_index FROM rh_swaps s WHERE s.token = u.token AND s.pool_id = u.pool_id "
+                "AND s.ts >= to_timestamp(%s) AND s.ts < to_timestamp(%s) AND s.price_q > 0 "
+                "ORDER BY s.ts DESC, s.block DESC, s.log_index DESC LIMIT %s) h ORDER BY u.pool_id, h.ts, h.block, h.log_index",
+                ([t for t, _ in first_day], [p for _, p in first_day], day0, t0, REF_LEGS)).fetchall():
+            ref.setdefault(h["pool_id"], deque(maxlen=REF_LEGS)).append(float(h["price_q"]))
     rows: dict[tuple, _Row] = {}
     for s in swaps:
         ts = s["ts"].timestamp(); day = int(ts // 86400)
-        if ref_day is None or day != ref_day:
+        if day != ref_day:
             ref = {}; ref_day = day
         p = float(s["price_q"] or 0.0)
         if p <= 0:
             continue
-        dq = ref.setdefault(s["token"], deque(maxlen=REF_LEGS))
+        dq = ref.setdefault(s["pool_id"], deque(maxlen=REF_LEGS))
         ok = not dq or (statistics.median(dq) / PRICE_BAND <= p <= statistics.median(dq) * PRICE_BAND)
         dq.append(p)
-        if not ok or ts < t0:
-            continue                                               # before t0: only the median's history
+        if not ok:
+            continue
         m = int(ts // 60) * 60
         key_b = (s["quote_asset"], m)
         if key_b not in base_cache:
@@ -80,9 +98,9 @@ def aggregate(conn, t0: int, t1: int, skill: dict | None = None, quote_asset: st
         resq_eth = float(s["resq_q"] or 0.0) * base
         if not (lo_band <= resq_eth <= hi_band):
             continue
-        r = rows.get((s["token"], m))
+        r = rows.get((s["token"], m, s["pool_id"]))
         if r is None:
-            r = rows[(s["token"], m)] = _Row(s["pool_id"], s["quote_asset"], s["cls"], base)
+            r = rows[(s["token"], m, s["pool_id"])] = _Row(s["pool_id"], s["quote_asset"], s["cls"], base)
         pe = p * base
         r.open = pe if r.open is None else r.open; r.high = max(r.high, pe); r.low = min(r.low, pe); r.close = pe; r.close_q = p
         vol = float(s["quote_raw"] or 0) / 10 ** int(s["qdec"]) * base
@@ -95,8 +113,13 @@ def aggregate(conn, t0: int, t1: int, skill: dict | None = None, quote_asset: st
         r.resq_eth, r.resq_q = resq_eth, float(s["resq_q"] or 0.0)
         if s["fee_frac"] is not None:
             r.fee_w += float(s["fee_frac"]) * vol; r.fee_v += vol
+    best: dict[tuple, _Row] = {}                                   # per (coin, minute): the pool with the most swaps
+    for (mint, m, _pool), r in rows.items():
+        b = best.get((mint, m))
+        if b is None or (r.nb + r.ns, r.buy + r.sell) > (b.nb + b.ns, b.buy + b.sell):
+            best[(mint, m)] = r
     out = []
-    for (mint, m), r in sorted(rows.items(), key=lambda kv: (kv[0][1], kv[0][0])):
+    for (mint, m), r in sorted(best.items(), key=lambda kv: (kv[0][1], kv[0][0])):
         if mint not in insiders:
             insiders[mint] = frozenset(x["wallet"] for x in conn.execute("SELECT wallet FROM rh_insiders WHERE mint = %s", (mint,)).fetchall())
         wc = minute_wallet_cols(r.wallets, insiders[mint], skill)
@@ -151,4 +174,6 @@ def run_once(rpc, skill: dict | None = None, max_minutes: int = 240) -> dict:
                      (json.dumps({"through": t1}),))
         conn.execute("INSERT INTO ui_settings (key, value) VALUES ('rh_stream_status', %s) ON CONFLICT (key) DO UPDATE SET value = EXCLUDED.value, updated_at = now()",
                      (json.dumps({"flushed_through": datetime.fromtimestamp(t1 - 60, timezone.utc).isoformat(), "rows": n}),))
+    from ..agent import live_first
+    live_first.minute_published()                       # committed: the engine's loop wakes now, not at its next poll
     return {"minutes": (t1 - done) // 60, "rows": n, "through": t1}

fly_trader/rh/prefetch.py

@@ -112,7 +112,7 @@ def selections(conn) -> list[dict]:
             H.selection([config.PONS_HOOK], [[index.FEE_TOPIC]])]
     hops: dict = {}
     for r in conn.execute("SELECT DISTINCT a.asset, a.ref_path::text AS ref_path FROM rh_assets a JOIN rh_pools p ON p.quote_asset = a.asset "
-                          "WHERE p.is_pons AND a.class <> 'eth' AND a.ref_path IS NOT NULL").fetchall():
+                          "WHERE (p.is_pons OR p.indexed) AND a.class <> 'eth' AND a.ref_path IS NOT NULL").fetchall():
         for h in json.loads(r["ref_path"]):
             hops.setdefault(prices._hop_key(h), h)
     plain = sorted({h["emitter"].lower() for h in hops.values() if not prices._is_id(h["pool"])})

fly_trader/rh/prices.py

@@ -175,9 +175,9 @@ def scan_asset(conn, rpc, asset: str, hops: list[dict], lo: int, hi: int, state:
 
 
 def base_eth(conn, asset: str | None, ts) -> tuple[float | None, bool]:
-    """(ETH per whole unit of ``asset`` at minute ``ts``, stale). ETH itself is 1. The last mark at or before the minute;
-    stale when older than ``STALE_S`` or flagged stale."""
-    if asset is None or int(asset, 16) == 0:
+    """(ETH per whole unit of ``asset`` at minute ``ts``, stale). ETH itself is 1, and so is WETH (a plain v4 memecoin's pool
+    may be quoted in either). The last mark at or before the minute; stale when older than ``STALE_S`` or flagged stale."""
+    if asset is None or int(asset, 16) == 0 or asset.lower() == config.RH_WETH.lower():
         return 1.0, False
     r = conn.execute("SELECT ts, price_eth, stale FROM rh_base_prices WHERE asset = %s AND ts <= %s ORDER BY ts DESC LIMIT 1", (asset.lower(), ts)).fetchone()
     if r is None:
@@ -195,7 +195,7 @@ def run_once(max_ranges: int = 1, rpc=None) -> dict:
     with transaction() as conn:
         top = conn.execute("SELECT block, detail FROM rh_scan WHERE name = 'rh'").fetchone()
         rows = conn.execute("SELECT DISTINCT a.asset, a.decimals, a.ref_path FROM rh_assets a JOIN rh_pools p ON p.quote_asset = a.asset "
-                            "WHERE p.is_pons AND a.class <> 'eth'").fetchall()
+                            "WHERE (p.is_pons OR p.indexed) AND a.class <> 'eth'").fetchall()
     if not top:
         return out
     through = int(top["block"])

fly_trader/rh/schema.py

@@ -139,6 +139,36 @@ RH_DDL: list[str] = [
     "ALTER TABLE positions ADD COLUMN IF NOT EXISTS gas_q double precision NOT NULL DEFAULT 0",
     "ALTER TABLE fly_scored ADD COLUMN IF NOT EXISTS chain text NOT NULL DEFAULT 'sol'",
     "ALTER TABLE notional_ledger ADD COLUMN IF NOT EXISTS market text NOT NULL DEFAULT 'sol'",
+    # ---- other Uniswap v4 pools (rh/v4_universe.py, 2026-10-23): a Pons coin's own pools outside its Pons pool ('pons_other')
+    # and plain memecoin pools ('v4'), registered once active past the floors. ``indexed``: live, its swaps indexed like a
+    # Pons pool's (rh/index.apply_v4) from block ``live_from``; ``ready_through``: its history before that, backfilled to
+    # this block (fly-trader rh-v4-backfill); ``lp_fee``: the static LP fee (None: dynamic, read per swap); ``swaps_seen``:
+    # its last half hour's swaps while not live (the contract checks take the busiest coins first)
+    "ALTER TABLE rh_pools ADD COLUMN IF NOT EXISTS kind text NOT NULL DEFAULT 'pons'",
+    "ALTER TABLE rh_pools ADD COLUMN IF NOT EXISTS indexed boolean NOT NULL DEFAULT false",
+    "ALTER TABLE rh_pools ADD COLUMN IF NOT EXISTS live_from bigint",
+    "ALTER TABLE rh_pools ADD COLUMN IF NOT EXISTS ready_through bigint",
+    "ALTER TABLE rh_pools ADD COLUMN IF NOT EXISTS lp_fee double precision",
+    "ALTER TABLE rh_pools ADD COLUMN IF NOT EXISTS init_tx text",
+    "ALTER TABLE rh_pools ADD COLUMN IF NOT EXISTS swaps_seen int NOT NULL DEFAULT 0",
+    "ALTER TABLE rh_pools ADD COLUMN IF NOT EXISTS last_swap_at timestamptz",
+    "CREATE INDEX IF NOT EXISTS rh_pools_indexed_idx ON rh_pools (indexed) WHERE indexed",
+    # every v4 pool's key from its Initialize (1.07 M pools by 2026-10-23; the Pons hook's are rh_pools'): what a pool
+    # is, once it trades. ``hooks`` NULL: none
+    """CREATE TABLE IF NOT EXISTS rh_v4_keys (
+        pool_id text PRIMARY KEY, currency0 text NOT NULL, currency1 text NOT NULL, fee int, tick_spacing int, hooks text,
+        init_block bigint NOT NULL, init_ts timestamptz, init_tx text, sqrt_price_x96 numeric(78,0), tick int)""",
+    "CREATE INDEX IF NOT EXISTS rh_v4_keys_c0_idx ON rh_v4_keys (currency0)",
+    "CREATE INDEX IF NOT EXISTS rh_v4_keys_c1_idx ON rh_v4_keys (currency1)",
+    # a plain v4 memecoin: its contract check (rh/token_check.py) and the facts its rh_meta row is built from
+    """CREATE TABLE IF NOT EXISTS rh_v4_tokens (
+        token text PRIMARY KEY, symbol text, name text, decimals int, supply_raw numeric(78,0), creator text,
+        first_pool text, first_block bigint, first_ts timestamptz, quote_asset text,
+        status text NOT NULL DEFAULT 'pending' CHECK (status IN ('pending', 'ok', 'refused', 'error')), reason text, detail jsonb,
+        attempts int NOT NULL DEFAULT 0, checked_at timestamptz, created_at timestamptz NOT NULL DEFAULT now())""",
+    "CREATE INDEX IF NOT EXISTS rh_v4_tokens_status_idx ON rh_v4_tokens (status)",
+    # where an rh_meta row comes from: a Pons launch ('pons') or a plain v4 memecoin ('v4', graduated_at = its first pool)
+    "ALTER TABLE rh_meta ADD COLUMN IF NOT EXISTS source text NOT NULL DEFAULT 'pons'",
     # rails circuit 3 (fly_trader/markets.RH_CIRCUIT); the id CHECK only allowed 1 before the Kalshi migration dropped it,
     # and an install still on the distribution's older ladder may carry it
     "ALTER TABLE circuit_state DROP CONSTRAINT IF EXISTS circuit_state_id_check",

fly_trader/rh/stream.py

@@ -10,6 +10,9 @@ from __future__ import annotations
 
 import json
 import logging
+import os
+import subprocess
+import sys
 import threading
 import time
 from datetime import datetime, timezone
@@ -26,6 +29,8 @@ LIVE_LAG_BLOCKS = 5_000         # closer than this to the head counts as live
 RPC_CATCHUP_S = 3.0             # between catch-up passes while HyperSync is down (each reads ~2-3 times from the public RPC)
 SLOW_EVERY_S = 60.0             # meta and corpus refresh with each written minute, else at least this often
 _SLOW = {"at": 0.0}
+_V4 = {"minute": None}          # the minute whose v4 slot ran (rh/v4_universe.slot: once a minute)
+_CORPUS: dict = {"proc": None}  # the child building a due corpus day (rh/corpus.run_locked)
 
 
 def _status(**kv) -> None:
@@ -82,13 +87,18 @@ def one_pass(rpc, skill=None) -> dict:
         px = prices.run_once(max_ranges=BACKFILL_RANGES if behind > LIVE_LAG_BLOCKS else 2, rpc=rpc); lap("prices")
     from . import wallet_skill
     wallet_skill.daily(); lap("skill_tables")                  # today's and tomorrow's tables, before their minutes are written
-    mn = minutes.run_once(src, wallet_skill.load_today() if skill is None else skill); lap("minutes")
-    from . import corpus, meta
+    try:
+        mn = minutes.run_once(src, wallet_skill.load_today() if skill is None else skill); lap("minutes")
+    finally:
+        if pre is not None and config.RH_V4_ENABLED:            # after the minute is written: the other v4 pools' logs, for the slot
+            from . import v4_universe
+            v4_universe.note(pre.logs)
+    from . import meta
     mt, cp = {}, {}
     if mn.get("minutes") or time.monotonic() - _SLOW["at"] >= SLOW_EVERY_S:   # after a written minute: passes in between stay short
         _SLOW["at"] = time.monotonic()
         mt = meta.run_once(); lap("meta")
-        cp = corpus.run_once(max_days=1) if behind <= LIVE_LAG_BLOCKS * 20 else {}      # the training corpus follows once near the head
+        cp = corpus_apart() if behind <= LIVE_LAG_BLOCKS * 20 else {}               # the training corpus follows once near the head
         lap("corpus")
     out = {"head": head, "index_through": ix.get("through"), "behind_blocks": head - (ix.get("through") or 0), "index": ix.get("counts"), "prices": px,
            "minutes": mn, "meta": mt, "corpus": cp, "mode": "backfill" if behind > LIVE_LAG_BLOCKS else "live", "timings_s": tm,
@@ -118,7 +128,70 @@ def main(stop_event: threading.Event | None = None) -> None:
         except Exception as e:
             log.exception("rh_stream pass failed: %s", str(e)[:200]); _status(error=str(e)[:300])
             stop.wait(10.0); continue
+        if config.RH_V4_ENABLED and out.get("mode") == "live":
+            v4_slot(out)
         stop.wait(_wait_s((out.get("minutes") or {}).get("through")))
+    _stop_corpus()
+
+
+def corpus_apart() -> dict:
+    """A due corpus day is built by a child process at the lowest CPU priority (``fly-trader rh-build-corpus``), never in
+    this thread (rh/corpus.py). One child at a time; this only looks at the files and starts it."""
+    from . import corpus
+    p = _CORPUS["proc"]
+    if p is not None and p.poll() is None:
+        return {"building": p.pid}
+    if p is not None:
+        _CORPUS["proc"] = None
+        if p.returncode:
+            log.warning("rh corpus child %d exited %d (its log: rh_corpus.log)", p.pid, p.returncode)
+    if not corpus.due():
+        return {}
+    nice = ["/usr/bin/nice", "-n", "19"] if os.path.exists("/usr/bin/nice") else []      # not preexec_fn: unsafe in a threaded process
+    p = _CORPUS["proc"] = subprocess.Popen([*nice, sys.executable, "-m", "fly_trader", "rh-build-corpus"], stdout=subprocess.DEVNULL)
+    log.info("rh corpus: a day is due, built by child process %d at the lowest CPU priority", p.pid)
+    return {"started": p.pid}
+
+
+def _stop_corpus() -> None:
+    p = _CORPUS["proc"]
+    if p is not None and p.poll() is None:
+        p.terminate()                                            # every file is written atomically: an ended child loses only its day
+        try:
+            p.wait(timeout=30)
+        except subprocess.TimeoutExpired:
+            p.kill()
+
+
+def _orders_pending() -> bool:
+    """A live order queued or in flight on either chain (the live mirrors, agent/live_first.py)."""
+    from ..agent import live_first
+    for chain in ("sol", "rh"):
+        m = live_first.mirror_of(chain)
+        q = getattr(m, "ex", None) or getattr(m, "worker", None)
+        try:
+            if q is not None and q.pending():
+                return True
+        except Exception:
+            return True
+    return False
+
+
+def v4_slot(out: dict, now: float | None = None) -> dict:
+    """The other v4 pools' work (rh/v4_universe.slot) once a minute, in this thread between passes: mid-minute
+    (agent/live_first.MID_MINUTE), once the newest minute is written, while HyperSync serves the live logs and no live
+    order is queued or in flight on either chain. It never waits for its window, and reads the RPC only until the
+    window's end. ``out``: the pass just made."""
+    from ..agent import live_first
+    from . import v4_universe
+    t = time.time() if now is None else now; m = int(t // 60)
+    through = int((out.get("minutes") or {}).get("through") or 0)
+    if _V4["minute"] == m or not live_first.mid_minute(t) or through < m * 60 or prefetch.hypersync_down() or _orders_pending():
+        return {}
+    _V4["minute"] = m
+    res = v4_universe.slot(deadline=m * 60 + live_first.MID_MINUTE[1], now=t)
+    _status(v4=res)
+    return res
 
 
 def _wait_s(written_through: int | None, now: float | None = None) -> float:

fly_trader/rh/token_check.py

@@ -0,0 +1,131 @@
+"""A plain Uniswap v4 memecoin's contract, checked before its pools are indexed (rh/v4_universe.py): what its owner can
+do to holders.
+
+Measured 2026-10-23 on the 118 tokens of Robinhood Chain pools that cleared the floors ($97M of 24 h volume): 76 % of the
+volume had no owner or admin powers (every Pons coin, Clanker, Pons V1, Pools.trade); the rest held upgradeable sell gates
+and blacklists under Pons tickers, owner-set taxes, bridge peers that mint, and built-in taxes.
+
+``check(rpc, token)`` reads the code (a minimal proxy is followed to its implementation; an EIP-1967 or beacon proxy is
+upgradeable and refused) and the dispatcher's selectors, and refuses a token whose owner (``owner()``, not renounced) or
+AccessControl roles hold a power (``POWERS``), one with a built-in buy or sell tax (``TAXES``), one that is not 18 decimals,
+and one whose name or symbol marks a major, a stablecoin or a tokenized stock. Functions are matched by selector: a power
+under an unusual name is missed, which the floors and the creator history (rh/meta.py) still stand behind.
+"""
+from __future__ import annotations
+
+import re
+
+from . import abi
+
+POWERS: dict[str, tuple[str, ...]] = {
+    "mint": ("mint(address,uint256)", "mint(uint256)", "mintTo(address,uint256)", "grantMintRole(address)", "grantMintAndBurnRoles(address)",
+             "setMinter(address,bool)", "addMinter(address)", "setPeer(uint32,bytes32)"),
+    "upgrade": ("upgradeTo(address)", "upgradeToAndCall(address,bytes)", "upgradeToSellGate()", "upgradeToBlacklist()"),
+    "blacklist": ("setBlacklist(address,bool)", "setBlacklistBatch(address[],bool)", "addBlacklistAddress(address)", "blacklist(address)",
+                  "addToBlacklist(address)", "blacklistAddress(address,bool)", "setSellTarget(address,bool)", "setSellTargets(address[],bool)",
+                  "blockVenue(address)", "setTransferAllowed(address,bool)", "setBot(address,bool)", "setBots(address[],bool)", "addBots(address[])",
+                  "freeze(address)"),
+    "pause": ("pause()",),
+    "tax setter": ("setFee(uint256)", "setFees(uint256,uint256)", "setTaxes(uint256,uint256)", "setTaxBps(uint16,uint16)", "setProjectTaxRates(uint16,uint16)",
+                   "setRateControl(uint16,uint16)", "setBuyFee(uint256)", "setSellFee(uint256)", "updateFees(uint256,uint256)"),
+    "transfer hook": ("setHook(address)", "setGateHook(address,bool)", "setPoolManagerGate(bool,bool)", "setMsgInspector(address)"),
+    "trading switch": ("enableTrading()", "openTrading()", "setMaxTxAmount(uint256)", "setMaxWalletSize(uint256)", "setLaunchLimits(uint16,uint16)",
+                       "lockPool(address)", "unlockPool()", "setLimitExempt(address,bool)", "setWalletExempt(address,bool)", "disableBalanceLimit()",
+                       "enableTransfers()"),
+}
+TAXES = ("buyTax()", "sellTax()", "buyFee()", "sellFee()", "taxWallet()", "buyTaxBps()", "sellTaxBps()", "totalBuyFeeBasisPoints()", "totalSellFeeBasisPoints()",
+         "projectBuyTaxBasisPoints()", "projectSellTaxBasisPoints()", "totalBuyTaxBasisPoints()", "totalSellTaxBasisPoints()", "buyFeePercent()",
+         "sellFeePercent()", "buyFeeBasisPoints()", "sellFeeBasisPoints()", "taxFee()", "getTaxConfig()")
+ROLES = ("hasRole(bytes32,address)", "grantRole(bytes32,address)")
+SEL: dict[str, tuple[str, str]] = {abi.selector(s).hex(): (cat, s) for cat, sigs in POWERS.items() for s in sigs}
+TAX_SEL = {abi.selector(s).hex() for s in TAXES}
+ROLE_SEL = {abi.selector(s).hex() for s in ROLES}
+OWNER_SEL = abi.selector("owner()").hex()
+IMPL_SLOT = "0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc"       # EIP-1967 implementation
+BEACON_SLOT = "0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50"     # EIP-1967 beacon
+CLONE_PREFIXES = ("363d3d373d3d3d363d73", "365f5f375f5f365f73", "3d3d3d3d363d3d37363d73")  # EIP-1167, its PUSH0 form, 0age's
+DEAD = {0, 0xdead, int("000000000000000000000000000000000000dEaD", 16)}
+MAJORS = {"ETH", "WETH", "USDG", "USDC", "USDT", "U", "USD", "DAI", "PYUSD", "USDE", "CBBTC", "WBTC", "HBTC", "BTC", "TBTC", "WSTETH", "STETH", "WEETH",
+          "EZETH", "RETH", "CBETH", "LINK", "HYPE", "TAO", "SOL", "WSOL", "ARB", "OP", "UNI", "AAVE", "VIRTUAL", "LIT", "RAM", "UP", "PONS"}
+STOCK_NAME = re.compile(r"robinhood token|tokeni[sz]ed|xstock|ondo|wrapped|bridged|\bstock\b", re.I)
+
+
+def selectors(code_hex: str) -> set[str]:
+    """The dispatcher's function selectors: each PUSH4 followed by EQ, DUP2, GT or LT, walking opcodes (PUSH data skipped)."""
+    b = bytes.fromhex(code_hex[2:] if code_hex.startswith("0x") else code_hex); i = 0; out = set()
+    while i < len(b):
+        op = b[i]
+        if op == 0x63 and i + 5 < len(b) and b[i + 5] in (0x14, 0x81, 0x11, 0x10):
+            out.add(b[i + 1:i + 5].hex())
+        i += 1 + (op - 0x5f if 0x60 <= op <= 0x7f else 0)
+    return out
+
+
+def clone_target(code_hex: str) -> str | None:
+    """The implementation a minimal proxy delegates to (EIP-1167 and its two shorter forms), else None."""
+    c = code_hex[2:] if code_hex.startswith("0x") else code_hex
+    for p in CLONE_PREFIXES:
+        if c.startswith(p) and len(c) >= len(p) + 40:
+            return "0x" + c[len(p):len(p) + 40]
+    return None
+
+
+def judge(sels: set[str], *, owner_live: bool, upgradeable: bool, decimals: int | None, symbol: str | None, name: str | None) -> tuple[bool, str, list[str]]:
+    """(accepted, reason, the powers found). Pure: ``check`` reads what it needs from the chain."""
+    powers = sorted({SEL[s][0] for s in sels if s in SEL})
+    if upgradeable:
+        return False, "upgradeable proxy: its owner can replace the code", powers
+    if decimals != 18:
+        return False, f"{decimals} decimals (only 18 are traded)", powers
+    sym = (symbol or "").strip().upper(); nm = name or ""
+    if sym in MAJORS or STOCK_NAME.search(nm):
+        return False, f"a major, stablecoin or tokenized asset ({symbol}, {name})", powers
+    if sels & TAX_SEL:
+        return False, "a built-in buy or sell tax", powers
+    if powers and (owner_live or sels & ROLE_SEL):
+        return False, ("its owner" if owner_live else "an admin role") + " can " + ", ".join(powers), powers
+    return True, "no owner or admin powers" if not powers else "powers with a renounced owner (" + ", ".join(powers) + ")", powers
+
+
+def _word_address(v) -> int:
+    try:
+        return int(v, 16) if isinstance(v, str) and v.startswith("0x") else 0
+    except ValueError:
+        return 0
+
+
+def _str(v) -> str | None:
+    if not isinstance(v, str) or len(v) < 2 + 128:
+        return None
+    try:
+        return abi.decode(["string"], bytes.fromhex(v[2:]))[0]
+    except Exception:
+        return None
+
+
+def check(rpc, token: str) -> dict:
+    """The contract check of ``token`` (two batched RPC reads at most). ``ok`` False with ``reason`` when refused; an
+    unreadable token raises (the caller retries later)."""
+    t = token.lower()
+    call = lambda sig: ("eth_call", [{"to": t, "data": "0x" + abi.selector(sig).hex()}, "latest"])      # noqa: E731
+    r = rpc.batch([("eth_getCode", [t, "latest"]), ("eth_getStorageAt", [t, IMPL_SLOT, "latest"]), ("eth_getStorageAt", [t, BEACON_SLOT, "latest"]),
+                   call("decimals()"), call("symbol()"), call("name()"), call("totalSupply()"), call("owner()")])
+    code = r[0] if isinstance(r[0], str) else None
+    if not code or code == "0x":
+        raise RuntimeError(f"no code at {t}")
+    ok = lambda v: isinstance(v, str)                                                                   # noqa: E731  (an EvmRpcError otherwise)
+    upgradeable = (ok(r[1]) and _word_address(r[1]) != 0) or (ok(r[2]) and _word_address(r[2]) != 0)
+    impl = clone_target(code); body = code
+    if impl:
+        body = rpc.batch([("eth_getCode", [impl, "latest"])])[0]
+        body = body if isinstance(body, str) else "0x"
+    sels = selectors(body)
+    dec = int(r[3], 16) if ok(r[3]) and r[3] not in ("0x", "") else None
+    owner = ("0x" + r[7][-40:]) if ok(r[7]) and len(r[7]) >= 42 else None
+    owner_live = OWNER_SEL in sels and owner is not None and int(owner, 16) not in DEAD
+    supply = int(r[6], 16) if ok(r[6]) and r[6] not in ("0x", "") else None
+    sym, nm = _str(r[4]), _str(r[5])
+    accepted, reason, powers = judge(sels, owner_live=owner_live, upgradeable=upgradeable, decimals=dec, symbol=sym, name=nm)
+    return {"ok": accepted, "reason": reason, "powers": powers, "decimals": dec, "symbol": sym, "name": nm, "supply_raw": supply, "impl": impl,
+            "owner": owner, "owner_live": owner_live, "upgradeable": upgradeable, "taxes": bool(sels & TAX_SEL), "roles": bool(sels & ROLE_SEL),
+            "code_len": (len(body) - 2) // 2, "n_selectors": len(sels)}

fly_trader/rh/v4_universe.py

@@ -0,0 +1,469 @@
+"""Robinhood Chain's other Uniswap v4 pools (2026-10-23): a Pons coin's own pools outside its Pons pool, and plain v4
+memecoins, traded like the Pons pools once they qualify.
+
+Measured 2026-10-23: 1.07 million v4 pools had been initialized on the chain, 700,000 of them without a hook. In one
+hour 1,480 pools traded (40,960 swaps, 3,375 of them in Pons pools); 85 hookless pools pairing a coin with ETH, WETH or
+USDG cleared the bot's floors (17,051 swaps), and 64 hooked ones did (4,810).
+
+Every PoolManager log already reaches the stream each live pass (rh/prefetch.py), and the index step dropped those
+outside the Pons pools (rh/index.step). Nothing below runs in front of a minute's publish:
+
+1. ``note`` (rh/stream.one_pass, once the pass's minutes are written): the pass's Initialize and Swap logs are kept.
+2. ``slot`` (rh/stream.v4_slot: mid-minute, once the newest minute is written, while no live order waits):
+   - the kept Initialize logs go to ``rh_v4_keys``, every pool's key (pools initialized before the stream kept them come
+     from ``fly-trader rh-v4-backfill``); the kept swaps to each pool's activity (``_ACT``, 15-minute buckets);
+   - a pool whose last half hour cleared the bot's floors (reserve and 15-minute volume, in ETH) is classified from its
+     key (``classify``) and registered in ``rh_pools`` (kind 'pons_other' or 'v4', not yet ``indexed``), and a plain
+     coin is queued in ``rh_v4_tokens``;
+   - ``RH_V4_CHECKS_PER_SLOT`` plain coins have their contract checked (rh/token_check.py), the busiest first;
+   - a qualifying pool goes live: its coin's rh_meta row (rh/meta.write_v4) and ``indexed`` with ``live_from`` (the
+     next block the stream indexes) in one commit, so the next pass indexes its swaps with the Pons pools'.
+3. ``backfill_main`` (``fly-trader rh-v4-backfill``, its own process): every Initialize since block 0 into
+   ``rh_v4_keys``, then each live pool's swaps before ``live_from`` with its coin's minutes over them, and a plain
+   coin's first-hour outcomes once its history is complete.
+
+Only the slot's contract checks reach the network: the RPC, each read once with a short timeout and none after the
+slot's end (``SlotRpc``). A rate limit or the slot's end leaves the rest for the next minute.
+"""
+from __future__ import annotations
+
+import json
+import logging
+import threading
+import time
+from datetime import datetime, timezone
+
+from .. import config
+from ..db.connection import transaction
+from ..vault.evm import EvmRpc, EvmRpcError
+from . import token_check, v4
+from .rpc import RhRpc, _rate_limited
+
+log = logging.getLogger(__name__)
+ZERO = "0x" + "00" * 20
+DYNAMIC_FEE = 0x800000          # a v4 pool's fee field with this flag: the LP fee is set per swap (the Swap event's fee)
+BUCKET_S = 900                  # a pool's activity in 15-minute buckets, the volume floor's window
+MIN_SWAPS = 5                   # swaps over the current and the previous bucket before a pool is looked at
+RECHECK_S = 900.0               # a pool below the floors, or without a known key, is looked at again after this long
+FORGET_S = 86400.0              # a pool that is no coin's pool (a hook, two quote assets): after this long
+KEEP_SWAPS = 200_000            # swap logs kept between slots (~5 h at 2026-10-23's rate); older ones are dropped
+SLOT_TIMEOUT_S = 5.0            # one RPC read of a slot
+MAX_ATTEMPTS = 5                # contract checks of a coin before it is given up ('error')
+HISTORY_CHUNK = 100_000         # backfill_main: blocks per history step (~3 h of chain)
+KEYS_STEP = 2_000_000           # backfill_main: blocks per key-import step
+_STASH: dict = {"inits": [], "swaps": []}
+_ACT: dict[str, list] = {}      # pool id -> [bucket, n, |amount0|, |amount1|, n before, |amount0| before, |amount1| before, sqrtPriceX96, tick, last ts]
+_KNOWN: set[str] = set()        # pools found in rh_pools (Pons pools, registered pools)
+_SEEN: dict[str, float] = {}    # pools looked at and not registered -> when to look again
+_RPC: dict = {"rpc": None}
+
+
+class SlotOver(RuntimeError):
+    """The slot's time is up, or the RPC refused it a read: the rest waits for the next minute."""
+
+
+class SlotRpc(RhRpc):
+    """The RPC for a slot's contract checks: each read once (no rate-limit waits), with a short timeout, and none after
+    ``deadline`` (epoch s); a rate limit or a timeout ends the slot's reads (``SlotOver``)."""
+
+    def __init__(self, url: str):
+        super().__init__(url, service="rh_v4", timeout=SLOT_TIMEOUT_S)
+        self.deadline = 0.0
+
+    def _guard(self, what: str, fn):
+        if time.time() > self.deadline:
+            raise SlotOver(f"the slot ended before {what}")
+        try:
+            return fn()
+        except EvmRpcError as e:
+            if _rate_limited(e) or "Timeout" in str(e):
+                raise SlotOver(f"{what}: {str(e)[:120]}") from None
+            raise
+
+    def call(self, method: str, params: list | None = None):
+        return self._guard(method, lambda: EvmRpc.call(self, method, params))
+
+    def batch(self, calls: list[tuple[str, list]]) -> list:
+        return self._guard("a batch", lambda: self._batch(calls))
+
+
+def slot_rpc(deadline: float) -> SlotRpc:
+    r = _RPC["rpc"]
+    if r is None:
+        r = _RPC["rpc"] = SlotRpc(config.RH_RPC_URL_LOGS or config.RH_RPC_URL)
+    r.deadline = deadline
+    return r
+
+
+# ---------------------------------------------------------------- what qualifies
+def _weth() -> str:
+    return config.RH_WETH.lower()
+
+
+def quote_ok_v4(asset: str) -> bool:
+    """A plain memecoin's quote: ETH, WETH or one of ``RH_V4_QUOTES``."""
+    a = asset.lower()
+    return a in (ZERO, _weth()) or a in config.RH_V4_QUOTES
+
+
+def hook_ok(hooks: str | None) -> bool:
+    h = (hooks or ZERO).lower()
+    return h == ZERO or h in config.RH_V4_HOOKS
+
+
+def classify(key: dict, assets: dict[str, dict], pons: dict[str, str]) -> dict | None:
+    """{"token", "quote", "kind"} for a pool key, or None (a Pons pool, a pair of two quote assets or of two unknown
+    tokens, a quote with no ETH mark, a hook that is not allowed). ``assets``: rh_assets by address (``priced``: class
+    'eth' or a reference path); ``pons``: the Pons launches among the pair -> status. A Pons coin's other pool counts once
+    the coin graduated; a Pons coin is never a plain v4 coin."""
+    c0, c1 = key["currency0"].lower(), key["currency1"].lower(); hooks = (key.get("hooks") or ZERO).lower()
+    if hooks == config.PONS_HOOK.lower() or not hook_ok(hooks):
+        return None
+    for tok, q in ((c0, c1), (c1, c0)):
+        if pons.get(tok) == "graduated" and q not in pons and (q in (ZERO, _weth()) or (assets.get(q) or {}).get("priced")):
+            return {"token": tok, "quote": q, "kind": "pons_other"}
+    if c0 in pons or c1 in pons:
+        return None
+    q0, q1 = quote_ok_v4(c0), quote_ok_v4(c1)
+    if q0 == q1:
+        return None
+    q, tok = (c0, c1) if q0 else (c1, c0)
+    if tok in assets or tok == _weth():
+        return None                                              # a quote asset (stable, stock, BTC) is not a memecoin
+    return {"token": tok, "quote": q, "kind": "v4"}
+
+
+def floors() -> tuple[float, float]:
+    """(reserve, 15-minute volume) in ETH: the RH book's entry floors (markets.RH, train/decisions)."""
+    from ..train.decisions import MIN_RESQ_SOL, MIN_VOL_15M_SOL
+    return MIN_RESQ_SOL * config.RH_ETH_PER_SOL, MIN_VOL_15M_SOL * config.RH_ETH_PER_SOL
+
+
+def activity(a: list, bucket: int) -> tuple[int, int, int]:
+    """(swaps, max |amount0|, max |amount1|) of a pool's buckets within the last half hour (``_ACT`` row)."""
+    cur = a[0] >= bucket - 1; prev = a[0] - 1 >= bucket - 1
+    n = (a[1] if cur else 0) + (a[4] if prev else 0)
+    return n, max(a[2] if cur else 0, a[5] if prev else 0), max(a[3] if cur else 0, a[6] if prev else 0)
+
+
+def clears(a: list, bucket: int, token_is_0: bool, qdec: int, base: float) -> tuple[bool, float, float]:
+    """(clears the floors, reserve ETH, best 15-minute volume ETH) of a pool from its activity and its last swap."""
+    _n, v0, v1 = activity(a, bucket)
+    if not a[7] or not a[8]:
+        return False, 0.0, 0.0                                   # no price or no liquidity after its last swap
+    resq = v4.quote_reserve(int(a[7]), int(a[8]), token_is_0, qdec) * base
+    vol = (v1 if token_is_0 else v0) / 10 ** qdec * base
+    min_resq, min_vol = floors()
+    return resq >= min_resq and vol >= min_vol, resq, vol
+
+
+# ---------------------------------------------------------------- the stream's pass and the slot
+def note(logs: list[dict]) -> None:
+    """Keep a pass's PoolManager Initialize and Swap logs for the next slot (rh/stream.one_pass, after its minutes)."""
+    pm = config.V4_POOL_MANAGER.lower(); init, swap = v4.TOPIC["Initialize"], v4.TOPIC["Swap"]
+    for g in logs:
+        t = g.get("topics") or ()
+        if not t or (g.get("address") or "").lower() != pm:
+            continue
+        t0 = t[0].lower()
+        if t0 == swap:
+            _STASH["swaps"].append(g)
+        elif t0 == init:
+            _STASH["inits"].append(g)
+    if len(_STASH["swaps"]) > KEEP_SWAPS:
+        del _STASH["swaps"][:len(_STASH["swaps"]) - KEEP_SWAPS]
+
+
+def tally(swaps: list[dict], now: float) -> int:
+    """Kept swap logs into each pool's activity (the current 15-minute bucket and the one before); idle pools dropped."""
+    n = 0
+    for g in swaps:
+        e = v4.decode(g)
+        if not e or e["event"] != "Swap":
+            continue
+        ts = e["ts"] or now; b = int(ts // BUCKET_S); a = _ACT.get(e["pool_id"])
+        if a is None:
+            a = _ACT[e["pool_id"]] = [b, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.0]
+        if b > a[0]:
+            a[4:7] = a[1:4] if b == a[0] + 1 else [0, 0, 0]
+            a[0], a[1], a[2], a[3] = b, 0, 0, 0
+        elif b < a[0]:
+            continue
+        a[1] += 1; a[2] += abs(int(e["amount0"])); a[3] += abs(int(e["amount1"]))
+        a[7], a[8], a[9], a[10] = e["sqrt_price_x96"], e["liquidity"], e["tick"], ts
+        n += 1
+    cut = int(now // BUCKET_S) - 1
+    for pid in [p for p, a in _ACT.items() if a[0] < cut]:
+        del _ACT[pid]
+    return n
+
+
+def save_keys(conn, rpc, inits: list[dict]) -> int:
+    """Decoded Initialize events -> ``rh_v4_keys`` (all but the Pons hook's pools: those are indexed as Pons pools)."""
+    pons_hook = config.PONS_HOOK.lower()
+    evs = [e for e in inits if (e.get("hooks") or ZERO).lower() != pons_hook]
+    if not evs:
+        return 0
+    if any(not e.get("ts") for e in evs):                       # logs the RPC served while HyperSync was down carry no time
+        from . import index
+        index.fill_timestamps(rpc, evs, min(e["block"] for e in evs), max(e["block"] for e in evs))
+    conn.cursor().executemany(
+        "INSERT INTO rh_v4_keys (pool_id, currency0, currency1, fee, tick_spacing, hooks, init_block, init_ts, init_tx, sqrt_price_x96, tick) "
+        "VALUES (%s, %s, %s, %s, %s, %s, %s, to_timestamp(%s), %s, %s, %s) ON CONFLICT (pool_id) DO NOTHING",
+        [(e["pool_id"], e["currency0"].lower(), e["currency1"].lower(), e.get("fee"), e.get("tick_spacing"),
+          None if (e.get("hooks") or ZERO).lower() == ZERO else e["hooks"].lower(), e["block"], e.get("ts"), e.get("tx_hash"),
+          e.get("sqrt_price_x96"), e.get("tick")) for e in evs])
+    return len(evs)
+
+
+def _assets(conn) -> dict[str, dict]:
+    return {r["asset"]: {"class": r["class"], "decimals": r["decimals"], "priced": r["class"] == "eth" or bool(r["has_path"])}
+            for r in conn.execute("SELECT asset, class, decimals, ref_path IS NOT NULL AS has_path FROM rh_assets").fetchall()}
+
+
+def discover(conn, now: float) -> dict:
+    """Register the active pools that cleared the floors over the last half hour (``classify`` on their keys)."""
+    from . import prices
+    b = int(now // BUCKET_S); out = {"looked": 0, "registered": 0, "no_key": 0, "below_floors": 0, "not_coin_pools": 0}
+    for pid in [p for p, when in _SEEN.items() if when <= now]:
+        del _SEEN[pid]
+    todo = [pid for pid, a in _ACT.items() if pid not in _KNOWN and pid not in _SEEN and activity(a, b)[0] >= MIN_SWAPS]
+    if not todo:
+        return out
+    known = {r["pool_id"] for r in conn.execute("SELECT pool_id FROM rh_pools WHERE pool_id = ANY(%s)", (todo,)).fetchall()}
+    _KNOWN.update(known)
+    todo = [p for p in todo if p not in known]
+    keys = {r["pool_id"]: dict(r) for r in conn.execute("SELECT * FROM rh_v4_keys WHERE pool_id = ANY(%s)", (todo,)).fetchall()}
+    side = sorted({k["currency0"] for k in keys.values()} | {k["currency1"] for k in keys.values()})
+    pons = {r["token"]: r["status"] for r in conn.execute("SELECT token, status FROM rh_tokens WHERE token = ANY(%s)", (side,)).fetchall()} if side else {}
+    assets = _assets(conn); at = datetime.fromtimestamp(now, timezone.utc)
+    for pid in todo:
+        out["looked"] += 1; k = keys.get(pid)
+        if k is None:
+            _SEEN[pid] = now + RECHECK_S; out["no_key"] += 1; continue                  # initialized before the stream kept keys
+        c = classify(k, assets, pons)
+        if c is None:
+            _SEEN[pid] = now + FORGET_S; out["not_coin_pools"] += 1; continue
+        if c["quote"] == _weth() and c["quote"] not in assets:
+            conn.execute("INSERT INTO rh_assets (asset, symbol, class, decimals) VALUES (%s, 'WETH', 'eth', 18) ON CONFLICT (asset) DO NOTHING", (c["quote"],))
+            assets = _assets(conn)
+        qa = assets.get(c["quote"]) or ({"decimals": 18} if c["quote"] == ZERO else None)
+        base = prices.base_eth(conn, c["quote"], at)[0] if qa else None
+        if qa is None or base is None:
+            _SEEN[pid] = now + RECHECK_S; out["below_floors"] += 1; continue
+        ti0 = k["currency0"].lower() == c["token"]
+        ok, resq, vol = clears(_ACT[pid], b, ti0, int(qa["decimals"]), float(base))
+        if not ok:
+            _SEEN[pid] = now + RECHECK_S; out["below_floors"] += 1; continue
+        register(conn, k, c, activity(_ACT[pid], b)[0])
+        _KNOWN.add(pid); out["registered"] += 1
+        log.info("rh v4: %s pool %s of %s registered (reserve %.2f ETH, 15-min volume %.2f ETH)", c["kind"], pid[:10], c["token"][:10], resq, vol)
+    return out
+
+
+def register(conn, key: dict, c: dict, swaps: int) -> None:
+    """A qualifying pool into ``rh_pools`` (not yet indexed); a plain coin into ``rh_v4_tokens`` (pending its check),
+    dated by the first pool of it ever initialized."""
+    tok = c["token"]; fee = int(key.get("fee") or 0); a = _ACT.get(key["pool_id"]) or [None] * 11
+    if c["kind"] == "v4":
+        first = conn.execute("SELECT pool_id, init_block, init_ts FROM rh_v4_keys WHERE currency0 = %(t)s OR currency1 = %(t)s "
+                             "ORDER BY init_block LIMIT 1", {"t": tok}).fetchone() or key
+        conn.execute("INSERT INTO rh_v4_tokens (token, first_pool, first_block, first_ts, quote_asset) VALUES (%s, %s, %s, %s, %s) ON CONFLICT (token) DO NOTHING",
+                     (tok, first["pool_id"], first["init_block"], first["init_ts"], c["quote"]))
+    conn.execute("INSERT INTO rh_pools (pool_id, token, currency0, currency1, token_is_0, fee, tick_spacing, hooks, quote_asset, init_block, init_ts, is_pons, "
+                 "kind, indexed, lp_fee, init_tx, sqrt_price_x96, tick, swaps_seen, last_swap_at) "
+                 "VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,false,%s,false,%s,%s,%s,%s,%s,to_timestamp(%s)) ON CONFLICT (pool_id) DO NOTHING",
+                 (key["pool_id"], tok, key["currency0"].lower(), key["currency1"].lower(), key["currency0"].lower() == tok, fee, key.get("tick_spacing"),
+                  (key.get("hooks") or ZERO).lower(), c["quote"], key["init_block"], key["init_ts"], c["kind"],
+                  None if fee & DYNAMIC_FEE else fee / 1e6, key.get("init_tx"), a[7] or key.get("sqrt_price_x96"), a[9] if a[9] is not None else key.get("tick"),
+                  swaps, a[10]))
+
+
+def refresh_activity(conn, now: float) -> None:
+    """Registered pools not yet live: their last half hour's swaps (``run_checks`` takes the busiest coins first)."""
+    b = int(now // BUCKET_S)
+    vals = [(pid, activity(a, b)[0], a[10]) for pid, a in _ACT.items() if pid in _KNOWN]
+    if vals:
+        conn.cursor().executemany("UPDATE rh_pools SET swaps_seen = %s, last_swap_at = to_timestamp(%s) WHERE pool_id = %s AND NOT is_pons AND NOT indexed",
+                                  [(n, ts, pid) for pid, n, ts in vals])
+
+
+def run_checks(conn, rpc, limit: int | None = None) -> dict:
+    """The contract check (rh/token_check.check) of the busiest pending coins; the creator is the sender of the coin's
+    first pool's initialization. A ``SlotOver`` ends the checks without counting an attempt."""
+    limit = config.RH_V4_CHECKS_PER_SLOT if limit is None else limit
+    todo = conn.execute("""SELECT v.token, (SELECT k.init_tx FROM rh_v4_keys k WHERE k.pool_id = v.first_pool) AS init_tx,
+                                  (SELECT coalesce(sum(p.swaps_seen), 0) FROM rh_pools p WHERE p.token = v.token) AS swaps
+                           FROM rh_v4_tokens v WHERE v.status = 'pending' AND v.attempts < %s ORDER BY swaps DESC, v.first_ts DESC LIMIT %s""",
+                        (MAX_ATTEMPTS, limit)).fetchall()
+    out = {"ok": 0, "refused": 0, "error": 0}
+    for t in todo:
+        try:
+            r = token_check.check(rpc, t["token"])
+            tx = rpc.tx_by_hash(t["init_tx"]) if t["init_tx"] else None
+            creator = ((tx or {}).get("from") or "").lower() or None
+        except SlotOver:
+            raise
+        except Exception as e:
+            conn.execute("UPDATE rh_v4_tokens SET attempts = attempts + 1, reason = %s, status = CASE WHEN attempts + 1 >= %s THEN 'error' ELSE status END, "
+                         "checked_at = now() WHERE token = %s", (str(e)[:300], MAX_ATTEMPTS, t["token"]))
+            out["error"] += 1; continue
+        st = "ok" if r["ok"] else "refused"
+        conn.execute("UPDATE rh_v4_tokens SET status = %s, reason = %s, detail = %s, symbol = %s, name = %s, decimals = %s, supply_raw = %s, creator = %s, "
+                     "attempts = attempts + 1, checked_at = now() WHERE token = %s",
+                     (st, r["reason"], json.dumps(r, default=str), r["symbol"], r["name"], r["decimals"], r["supply_raw"], creator, t["token"]))
+        out[st] += 1
+        log.info("rh v4 coin %s (%s): %s, %s", t["token"], r["symbol"], st, r["reason"])
+    return out
+
+
+def go_live(conn, cursor: int) -> int:
+    """Each registered pool that qualifies now (a graduated Pons coin's, or an accepted plain coin's) goes live: its
+    coin's rh_meta row and ``indexed`` with ``live_from`` = the next block the stream indexes, in this commit. Runs in
+    the stream's thread between passes, so the cursor cannot move under it."""
+    from . import meta
+    rows = conn.execute("""SELECT p.pool_id, p.token, p.kind FROM rh_pools p LEFT JOIN rh_v4_tokens v ON v.token = p.token
+                           WHERE NOT p.is_pons AND NOT p.indexed AND p.kind IN ('pons_other', 'v4')
+                             AND ((p.kind = 'pons_other' AND EXISTS (SELECT 1 FROM rh_meta m WHERE m.mint = p.token)) OR (p.kind = 'v4' AND v.status = 'ok'))
+                           ORDER BY p.swaps_seen DESC""").fetchall()
+    n = 0
+    for r in rows:
+        if r["kind"] == "v4" and not meta.write_v4(conn, r["token"]):
+            continue
+        conn.execute("UPDATE rh_pools SET indexed = true, live_from = %s WHERE pool_id = %s", (cursor + 1, r["pool_id"]))
+        n += 1
+        log.info("rh v4: %s pool %s of %s live from block %d", r["kind"], r["pool_id"][:10], r["token"][:10], cursor + 1)
+    return n
+
+
+def slot(deadline: float, now: float | None = None) -> dict:
+    """One minute's work (module docstring, step 2), in the stream's thread between passes. What it did, for the
+    stream's status."""
+    t = time.time() if now is None else now; t0 = time.monotonic()
+    out: dict = {"at": datetime.fromtimestamp(t, timezone.utc).isoformat()}
+    inits, swaps = _STASH["inits"], _STASH["swaps"]; _STASH["inits"], _STASH["swaps"] = [], []
+    out["swaps"] = tally(swaps, t)
+    rpc = slot_rpc(deadline)
+    try:
+        with transaction() as conn:
+            out["keys"] = save_keys(conn, rpc, [e for e in (v4.decode(g) for g in inits) if e])
+            out.update(discover(conn, t))
+            refresh_activity(conn, t)
+    except SlotOver as e:
+        _STASH["inits"][:0] = inits; out["stopped"] = str(e)[:200]
+    except Exception as e:
+        _STASH["inits"][:0] = inits; out["error"] = str(e)[:200]; log.exception("rh v4 slot: discovery failed")
+    try:
+        with transaction() as conn:
+            out["checks"] = run_checks(conn, rpc)
+    except SlotOver as e:
+        out["stopped"] = str(e)[:200]
+    except Exception as e:
+        out["error"] = str(e)[:200]; log.exception("rh v4 slot: contract checks failed")
+    try:
+        with transaction() as conn:
+            cur = conn.execute("SELECT block FROM rh_scan WHERE name = 'rh'").fetchone()
+            out["live"] = go_live(conn, int(cur["block"])) if cur else 0
+            out["v4"] = status(conn)
+    except Exception as e:
+        out["error"] = str(e)[:200]; log.exception("rh v4 slot: going live failed")
+    out["active_pools"] = len(_ACT); out["took_s"] = round(time.monotonic() - t0, 2)
+    return out
+
+
+def status(conn) -> dict:
+    """Counts for the console and the logs."""
+    r = conn.execute("""SELECT count(*) FILTER (WHERE kind = 'pons_other') AS pons_other, count(*) FILTER (WHERE kind = 'v4') AS v4,
+                               count(*) FILTER (WHERE indexed) AS live FROM rh_pools WHERE NOT is_pons""").fetchone()
+    t = {x["status"]: x["n"] for x in conn.execute("SELECT status, count(*) AS n FROM rh_v4_tokens GROUP BY 1").fetchall()}
+    return {**dict(r), "coins": t}
+
+
+# ---------------------------------------------------------------- fly-trader rh-v4-backfill (its own process)
+def import_keys(rpc, stop: threading.Event) -> int:
+    """Every Initialize from block 0 to the stream's cursor into ``rh_v4_keys`` (resumable: cursor ``rh_v4_inits``)."""
+    from . import index
+    n = 0
+    with transaction() as conn:
+        r = conn.execute("SELECT block FROM rh_scan WHERE name = 'rh_v4_inits'").fetchone()
+        top = conn.execute("SELECT block FROM rh_scan WHERE name = %s", (index.CURSOR,)).fetchone()
+    frm = int(r["block"]) + 1 if r else 0; to = int(top["block"]) if top else 0
+    while frm <= to and not stop.is_set():
+        hi = min(to, frm + KEYS_STEP - 1)
+        logs = index._get_logs(rpc, [config.V4_POOL_MANAGER], frm, hi, [[v4.TOPIC["Initialize"]]])
+        with transaction() as conn:
+            k = save_keys(conn, rpc, [e for e in (v4.decode(g) for g in logs) if e])
+            conn.execute("INSERT INTO rh_scan (name, block) VALUES ('rh_v4_inits', %s) ON CONFLICT (name) DO UPDATE SET block = EXCLUDED.block, updated_at = now()", (hi,))
+        n += k; log.info("rh v4 keys: blocks %d..%d, %d pools", frm, hi, k)
+        frm = hi + 1
+    return n
+
+
+def backfill_pool(conn, rpc, p: dict, hi: int) -> dict:
+    """One history step of a live pool: its logs from ``p["lo"]`` to ``hi`` (< its ``live_from``), its coin's minutes
+    over them recomputed (each day with that day's skill table, never past the minutes the stream has written), and
+    ``ready_through = hi``."""
+    from . import index, minutes, wallet_skill
+    lo = int(p["lo"])
+    logs = index._get_logs(rpc, [config.V4_POOL_MANAGER], lo, hi, [index.V4_TOPICS0, [p["pool_id"]]])
+    n = index.apply_v4(conn, rpc, logs, [], pool_ids=[p["pool_id"]])
+    evs = [e for e in (v4.decode(g) for g in logs) if e and e.get("ts")]
+    if evs:
+        r = conn.execute("SELECT detail FROM rh_scan WHERE name = 'rh_minutes'").fetchone()
+        through = int(((r["detail"] or {}) if r else {}).get("through") or 0)
+        t0 = int(min(e["ts"] for e in evs) // 60) * 60; t1 = min(through, int(max(e["ts"] for e in evs) // 60) * 60 + 60)
+        d = t0 - t0 % 86400
+        while d < t1:
+            a, z = max(t0, d), min(t1, d + 86400)
+            if z > a:
+                minutes.write(conn, minutes.aggregate(conn, a, z, wallet_skill.table_for(datetime.fromtimestamp(d, timezone.utc).date()), tokens=[p["token"]]))
+            d += 86400
+    conn.execute("UPDATE rh_pools SET ready_through = %s WHERE pool_id = %s", (hi, p["pool_id"]))
+    return {"logs": len(logs), **n}
+
+
+def backfill_history(rpc, stop: threading.Event) -> dict:
+    """Each live pool's swaps before its ``live_from`` (busiest first), then a plain coin's first-hour outcomes once its
+    pools' histories are complete."""
+    from . import meta
+    out = {"pools": 0, "steps": 0, "outcomes": 0}
+    with transaction() as conn:
+        pools = [dict(r) for r in conn.execute(
+            """SELECT pool_id, token, kind, live_from, coalesce(ready_through, init_block - 1) + 1 AS lo FROM rh_pools
+               WHERE NOT is_pons AND indexed AND live_from IS NOT NULL AND coalesce(ready_through, init_block - 1) < live_from - 1
+               ORDER BY swaps_seen DESC""").fetchall()]
+    for p in pools:
+        while not stop.is_set() and int(p["lo"]) <= int(p["live_from"]) - 1:
+            hi = min(int(p["live_from"]) - 1, int(p["lo"]) + HISTORY_CHUNK - 1)
+            with transaction() as conn:
+                r = backfill_pool(conn, rpc, p, hi)
+            out["steps"] += 1; p["lo"] = hi + 1
+            log.info("rh v4 history %s (%s): through block %d, %s", p["pool_id"][:10], p["kind"], hi, r)
+        out["pools"] += 1
+        if stop.is_set():
+            break
+    with transaction() as conn:                                  # plain coins whose every live pool has its history
+        due = conn.execute("""SELECT m.mint, m.graduated_at FROM rh_meta m WHERE m.source = 'v4' AND m.own_dd60 IS NULL
+                              AND NOT EXISTS (SELECT 1 FROM rh_pools p WHERE p.token = m.mint AND p.indexed AND NOT p.is_pons
+                                              AND coalesce(p.ready_through, p.init_block - 1) < p.live_from - 1)""").fetchall()
+        for r in due:
+            o = meta.outcomes(conn, r["mint"], r["graduated_at"])
+            if o is not None:
+                conn.execute("UPDATE rh_meta SET own_dd60 = %s, own_max60 = %s, updated_at = now() WHERE mint = %s", (o[0], o[1], r["mint"])); out["outcomes"] += 1
+    return out
+
+
+def backfill_main(stop_event: threading.Event | None = None, keys: bool = True, history: bool = True) -> dict:
+    """``fly-trader rh-v4-backfill``: the key import, then the live pools' histories. Run it apart from the console, under
+    nice; it paces HyperSync at ``RH_V4_BACKFILL_RPM`` of its own, so the console keeps its share of the plan."""
+    from ..logging_setup import setup
+    from .rpc import logs_rpc
+    setup("rh_v4_backfill"); stop = stop_event or threading.Event()
+    config.RH_HYPERSYNC_RPM = config.RH_V4_BACKFILL_RPM
+    rpc = logs_rpc(); out: dict = {}
+    if keys:
+        out["keys"] = import_keys(rpc, stop)
+    if history and not stop.is_set():
+        out.update(backfill_history(rpc, stop))
+    log.info("rh v4 backfill done: %s", out)
+    return out

fly_trader/signer/core.py

@@ -21,6 +21,7 @@ import os
 import subprocess
 import tempfile
 import time
+from concurrent.futures import ThreadPoolExecutor
 from dataclasses import dataclass, field
 
 from solders.address_lookup_table_account import AddressLookupTable
@@ -40,6 +41,7 @@ from .rpc import Rpc
 RENT_EXEMPT_MIN = 890_880          # a 0-byte system account: the treasury PDA must keep this much
 LAMPORTS = 1_000_000_000
 SIM_MAX_ACCOUNTS = 20                # the RPC caps accounts per simulation (30, or fewer: it has said 27)
+_IO = ThreadPoolExecutor(max_workers=6, thread_name_prefix="signer-io")    # a swap's reads, side by side
 
 
 @dataclass
@@ -140,18 +142,25 @@ class Signer:
                 raise PolicyError("daily buy volume cap reached", code="cap")
         vt = VersionedTransaction.from_bytes(base64.b64decode(tx))
         chk = policy.check_swap_static(vt, me, self._resolve_alt, self.cfg.max_priority_lamports)
-        # every token account the trading wallet owns, plus the two this swap may open
-        mint_acc = self.rpc.accounts([in_m, out_m])
+        # every token account the trading wallet owns, plus the two this swap may open (the reads side by side: a live
+        # order waits on this signature)
+        tok = out_m if buy else in_m
+        f_mints = _IO.submit(self.rpc.accounts, [in_m, out_m])
+        f_spl, f_t22 = _IO.submit(self.rpc.token_accounts, me, TOKEN), _IO.submit(self.rpc.token_accounts, me, TOKEN_2022)
+        f_prices = _IO.submit(self.rpc.usd_prices, [str(tok), str(NATIVE_MINT)])
+        mint_acc = f_mints.result()
         progs = {m: (a["owner"] if a else TOKEN) for m, a in zip((in_m, out_m), mint_acc)}
-        addrs = [me] + self.rpc.token_accounts(me, TOKEN) + self.rpc.token_accounts(me, TOKEN_2022)
+        addrs = [me] + f_spl.result() + f_t22.result()
         for m in (in_m, out_m):
             a = policy.ata(me, m, progs[m])
             if a not in addrs:
                 addrs.append(a)
-        pre = self._snapshot(self.rpc.accounts(addrs), addrs)
+        f_pre = _IO.submit(self.rpc.accounts, addrs)
+        f_sims = [_IO.submit(self.rpc.simulate, tx, addrs[i:i + SIM_MAX_ACCOUNTS]) for i in range(0, len(addrs), SIM_MAX_ACCOUNTS)]   # in chunks: the RPC caps accounts per simulation
+        pre = self._snapshot(f_pre.result(), addrs)
         post_accs: list[dict | None] = []
-        for i in range(0, len(addrs), SIM_MAX_ACCOUNTS):          # in chunks: the RPC caps accounts per simulation
-            sim = self.rpc.simulate(tx, addrs[i:i + SIM_MAX_ACCOUNTS])
+        for f in f_sims:
+            sim = f.result()
             if sim.get("err") is not None:
                 raise PolicyError(f"the swap fails in simulation: {sim['err']} {(sim.get('logs') or [])[-3:]}", code="in_flight")
             post_accs += [None if a is None else {"lamports": a["lamports"], "owner": Pubkey.from_string(a["owner"]), "data": base64.b64decode(a["data"][0])}
@@ -159,9 +168,8 @@ class Signer:
         post = self._snapshot(post_accs, addrs)
         slack = policy.BASE_FEE_LAMPORTS * vt.message.header.num_required_signatures + chk.priority_lamports + 10_000
         eff = policy.check_swap_effects(pre, post, in_mint=in_m, out_mint=out_m, in_amount=int(in_amount), min_out=int(min_out), slack_lamports=slack)
-        tok = out_m if buy else in_m
         tok_acc = mint_acc[1] if buy else mint_acc[0]
-        prices = self.rpc.usd_prices([str(tok), str(NATIVE_MINT)])
+        prices = f_prices.result()
         ratio = policy.check_value("buy" if buy else "sell", eff["sol"], abs(eff["token"]), tok_acc["data"][44] if tok_acc else 0,
                                    prices.get(str(tok)), prices.get(str(NATIVE_MINT)), self.cfg.min_value_ratio)
         sigs = list(vt.signatures)

fly_trader/train/corpus_meta.py

@@ -19,6 +19,10 @@ the stream fills ``own_dd60``/``own_max60`` from its own minutes at that time, t
 the assembled candle files. Runs inside the ``replay`` worker after each assembly round and as
 ``fly-trader build-corpus-meta``. It first copies the archive's directly created PumpSwap pools into ``pump_pools``
 (``backfill_pump_pools``), which the stream and ``train/mature.py`` exclude from the universe (``blocked_pool_ids``).
+
+The universe's coins are pump.fun's: a mint ending in ``pump`` or one this table holds (a pump.fun migration recorded it).
+Since 2026-10-23 the second half counts too: 4-22 % of daily graduations carry a mint without the suffix, with the same
+launchpad, creator history, burned pool liquidity and token rules as the rest (``pumpfun_graduates``).
 """
 from __future__ import annotations
 
@@ -35,11 +39,39 @@ from .. import config
 from ..db.connection import transaction
 
 log = logging.getLogger(__name__)
+WSOL = "So11111111111111111111111111111111111111112"
+# Inputs in the graduation's quote units: SOL for a SOL graduation, but USDC, a stock token's or another coin's units when
+# pump.fun seeded the pool in those (17 % of graduations on 2026-10-20). They are SOL inputs only when the quote is SOL or
+# not known (the archive before 2026-10-23 did not keep it); otherwise they read as unknown (``sol_select``).
+QUOTE_UNIT_COLS = ("dev_sol", "rq0")
+# the venues whose SOL legs make a pump.fun coin's minutes, live (ingest/pumpstream.py) and in training (train/mature.py):
+# its PumpSwap pools and, since 2026-10-23, its Meteora DLMM pools (each minute keeps the pool with the most legs)
+UNIVERSE_POOLS = ("pump-amm", "meteora-dlmm")
 CURVE_COLS = ["bundle_share", "dev_hold_share", "dev_sold_frac", "grad_hhi"]
 FEATURE_COLS = ["ttg_min", "dev_sol", "dev_share", "mayhem", "rq0", "prior_launches", "prior_grads", "prior_known", "prior_rug_share", "prior_moon_share",
                 *CURVE_COLS, "curve_known"]
 
 
+def sol_select(cols) -> str:
+    """The SELECT list for ``cols`` of ``corpus_meta`` with ``QUOTE_UNIT_COLS`` as SOL inputs: NULL (unknown) when the
+    graduation's pool was seeded in another quote (``grad_quote``). Live (agent/minute_engine.py) and training
+    (``load_features``) read them the same way."""
+    return ", ".join(f"CASE WHEN grad_quote IS NULL OR grad_quote = '{WSOL}' THEN {c} END AS {c}" if c in QUOTE_UNIT_COLS else c for c in cols)
+
+
+def record_grad_quotes(conn, seen) -> int:
+    """``seen``: (mint, pool id, quote mint) of trades the stream saw in a graduate's own pool (``corpus_meta.pool_id``):
+    that pool's quote is the graduation's. Fills ``grad_quote`` where it is still unknown (graduations before the archive
+    kept the migration's quote). Returns rows updated."""
+    seen = [t for t in seen if all(t)]
+    if not seen:
+        return 0
+    cur = conn.cursor()
+    cur.executemany("UPDATE corpus_meta SET grad_quote = %s, updated_at = now() WHERE mint = %s AND pool_id = %s AND grad_quote IS NULL",
+                    [(q, m, p) for m, p, q in seen])
+    return max(cur.rowcount, 0)
+
+
 def curve_facts(create_slot: int | None, creator: str | None, supply: float | None, initial_buy: float | None, wallets: dict) -> tuple[dict, list[tuple[str, str]]]:
     """Graduation-time rug facts from a token's bonding-curve trading, one definition for the archive (``update_curve_facts``)
     and the live stream (``ingest/pumpstream.py``). ``wallets``: wallet → [first buy slot or None, tokens bought, tokens sold]
@@ -99,9 +131,12 @@ def rebuild(outcome_batch: int = 20000) -> int:
     n_pp = backfill_pump_pools()               # before mature.loop_once aggregates the new days
     creates =con.execute(f"""SELECT mint, min(ts) AS create_ts, arg_min(signer, ts) AS creator, arg_min(quote_amount, ts) AS dev_sol,
                               arg_min(initial_buy, ts) AS dev_tokens, arg_min(supply, ts) AS supply, arg_min(mayhem, ts) AS mayhem, arg_min(uri, ts) AS uri,
-                              arg_min(name, ts) AS name, arg_min(symbol, ts) AS symbol, arg_min(sig, ts) AS sig FROM read_parquet('{ev}') WHERE action = 'create' AND pool = 'pump' GROUP BY mint""").df()
-    migr = con.execute(f"""SELECT mint, min(ts) AS g, arg_min(quote_in_pool, ts) AS rq0, arg_min(pool_id, ts) AS pool_id
-                           FROM read_parquet('{ev}') WHERE action = 'migrate' AND pool = 'pump-amm' GROUP BY mint""").df()
+                              arg_min(name, ts) AS name, arg_min(symbol, ts) AS symbol, arg_min(sig, ts) AS sig FROM read_parquet('{ev}', union_by_name = true)
+                              WHERE action = 'create' AND pool = 'pump' GROUP BY mint""").df()
+    ev_cols = [c[0] for c in con.execute(f"SELECT * FROM read_parquet('{ev}', union_by_name = true) LIMIT 0").description]
+    gq = "arg_min(quote_mint, ts) FILTER (WHERE quote_mint IS NOT NULL)" if "quote_mint" in ev_cols else "NULL::VARCHAR"     # kept since 2026-10-23
+    migr = con.execute(f"""SELECT mint, min(ts) AS g, arg_min(quote_in_pool, ts) AS rq0, arg_min(pool_id, ts) AS pool_id, {gq} AS grad_quote
+                           FROM read_parquet('{ev}', union_by_name = true) WHERE action = 'migrate' AND pool = 'pump-amm' GROUP BY mint""").df()
     con.close()
     meta = migr.merge(creates, on="mint", how="left")
     meta["ttg_min"] = (meta["g"] - meta["create_ts"]).dt.total_seconds() / 60.0
@@ -140,12 +175,13 @@ def rebuild(outcome_batch: int = 20000) -> int:
     meta = meta.merge(hist[["mint", "prior_grads", "prior_known", "prior_rug_share", "prior_moon_share"]], on="mint", how="left")
     meta["graduated_at"] = meta["g"]
     cols = ["mint", "graduated_at", "create_ts", "creator", "dev_sol", "dev_tokens", "dev_share", "supply", "mayhem", "uri", "name", "symbol", "ttg_min", "rq0", "pool_id",
-            "prior_launches", "prior_grads", "prior_known", "prior_rug_share", "prior_moon_share", "own_dd60", "own_max60", "own_alive6h"]
+            "prior_launches", "prior_grads", "prior_known", "prior_rug_share", "prior_moon_share", "own_dd60", "own_max60", "own_alive6h", "grad_quote"]
+    keep_known = {"grad_quote"}             # the archive's quote when it has one, else the stream's (record_grad_quotes)
     rows = [tuple(_pg(v) for v in rec) for rec in meta[cols].itertuples(index=False, name=None)]
     with transaction() as conn:
         conn.cursor().executemany(
             "INSERT INTO corpus_meta (" + ",".join(cols) + ") VALUES (" + ",".join(["%s"] * len(cols)) + ") ON CONFLICT (mint) DO UPDATE SET " +
-            ", ".join(f"{c} = EXCLUDED.{c}" for c in cols if c != "mint") + ", updated_at = now()", rows)
+            ", ".join(f"{c} = COALESCE(EXCLUDED.{c}, corpus_meta.{c})" if c in keep_known else f"{c} = EXCLUDED.{c}" for c in cols if c != "mint") + ", updated_at = now()", rows)
     n_cr = _backfill_creates(creates)
     n_curve = update_curve_facts()
     log.info("corpus_meta rebuilt: %d graduated tokens (%d with creator, %d with outcomes), %d archive creates added to pump_events, %d custom pools to pump_pools, "
@@ -300,9 +336,20 @@ def backfill_pump_pools() -> int:
 
 
 def blocked_pool_ids(conn) -> list[str]:
-    """Blocked pools that can carry universe legs. The stream and ``train/mature.py`` both keep only pump.fun-origin mints
-    (suffix ``pump``) before this check, so pools of other mints never match either way."""
-    return [r["pool_id"] for r in conn.execute("SELECT pool_id FROM pump_pools WHERE mint IS NULL OR right(mint, 4) = 'pump'").fetchall()]
+    """Blocked pools that can carry universe legs: those of pump.fun's coins (a ``pump`` mint or a graduate in this table).
+    The stream and ``train/mature.py`` keep only those coins before this check, so pools of other mints never match either
+    way (and the set stays ~10 % of ``pump_pools``). Read as two halves joined on the indexes: one ``corpus_meta`` probe per
+    pool row took 3.5 s (2026-10-23)."""
+    return [r["pool_id"] for r in conn.execute("""SELECT pool_id FROM pump_pools WHERE mint IS NULL OR right(mint, 4) = 'pump'
+                                                  UNION ALL
+                                                  SELECT p.pool_id FROM pump_pools p JOIN corpus_meta c ON c.mint = p.mint
+                                                  WHERE right(p.mint, 4) <> 'pump'""").fetchall()]
+
+
+def pumpfun_graduates(conn) -> list[str]:
+    """pump.fun graduates whose mint does not end in ``pump`` (a migration recorded them here): universe coins as much as
+    the suffixed ones, which the stream and the archive aggregation recognise by the suffix alone."""
+    return [r["mint"] for r in conn.execute("SELECT mint FROM corpus_meta WHERE right(mint, 4) <> 'pump'").fetchall()]
 
 
 def creator_history(conn, creator: str | None, create_ts, graduated_at) -> dict:
@@ -328,7 +375,7 @@ def creator_history(conn, creator: str | None, create_ts, graduated_at) -> dict:
 
 def load_features() -> pd.DataFrame:
     with transaction() as conn:
-        rows = conn.execute("SELECT mint, " + ", ".join(FEATURE_COLS) + " FROM corpus_meta").fetchall()
+        rows = conn.execute("SELECT mint, " + sol_select(FEATURE_COLS) + " FROM corpus_meta").fetchall()
     df = pd.DataFrame(rows)
     if df.empty:
         return pd.DataFrame(columns=["mint"] + FEATURE_COLS)

fly_trader/train/fly_replay.py

@@ -429,7 +429,7 @@ def merge_chains(row, out: dict, only_chains: tuple) -> dict:
     """The stored verdict with ``out``'s verdicts for ``only_chains`` put in; the other chains keep theirs (each with the
     replay start it was judged from). A stored verdict on other definitions is replaced whole."""
     old = (row["value"] if isinstance(row["value"], dict) else json.loads(row["value"])) if row else None
-    if not old or old.get("data") != out.get("data") or "chains" not in old:
+    if not old or not isinstance(out.get("data"), dict) or not selector.defs_match(old.get("data"), out["data"]) or "chains" not in old:
         return out
     chains = dict(old["chains"])
     for c in only_chains:
@@ -581,7 +581,7 @@ def verdict() -> dict | None:
     with transaction() as conn:
         r = conn.execute("SELECT value FROM ui_settings WHERE key = %s", (KEY,)).fetchone()
     v = (r["value"] if isinstance(r["value"], dict) else json.loads(r["value"] or "{}")) if r else None
-    return v if v and v.get("data") == fly_selector.verdict_version() else None
+    return v if v and selector.defs_match(v.get("data"), fly_selector.verdict_version()) else None
 
 
 def main(days: int | None = None, start_day: int = START_DAY, stop_event: threading.Event | None = None, only_chains: tuple | None = None) -> dict:

fly_trader/train/fly_selector.py

@@ -69,6 +69,7 @@ EPOCHS, BATCH = 8, 512       # EPOCHS only caps the runtime; early stopping belo
 TOP_WEIGHT = 10.0            # loss weight of the teacher's top 1 % of training minutes
 DISTIL_TOP, DISTIL_SAMPLE = 0.05, 3_000_000
 RECAL_ROWS = 200_000
+CHECKPOINT = config.BRAIN_DIR / "policies" / "fly_bootstrap.ckpt.pt"     # the live bootstrap's epochs so far (main): a stopped run resumes
 VAL_ROWS, VAL_MIN_ROWS = 200_000, 100_000   # distillation rows held out to judge the fit; a smaller slice is too noisy to stop on
 MIN_EPOCHS = 2               # never stop on one epoch: it has nothing to be compared against
 LR_GRAPH, LR_HEAD = 1e-4, 1e-3
@@ -427,13 +428,38 @@ def _val_mse(net: FlyNet, scaler: RobustScaler, ds: DecisionSet, idx: np.ndarray
     return float(e.mean()), float(e.std() / max(len(e) ** 0.5, 1.0))
 
 
+def _resume(path, fp: dict) -> dict | None:
+    """The checkpoint at ``path`` when it was written for this same training set (``fp``): training resumes after its last
+    epoch. One written for other data is set aside (``.stale``) and training starts fresh."""
+    p = Path(path)
+    if not p.exists():
+        return None
+    ck = model_io.torch_load(p)
+    if ck.get("fingerprint") != fp:
+        stale = p.with_name(p.name + ".stale"); p.replace(stale)
+        log.warning("fly checkpoint %s was written for other training data (%s; now %s): set aside as %s, training starts fresh",
+                    p.name, ck.get("fingerprint"), fp, stale.name)
+        return None
+    log.info("fly training resumes after epoch %d from %s", int(ck["epoch"]), p)
+    return ck
+
+
+def _write_checkpoint(path, obj: dict) -> None:
+    """``obj`` at ``path``, atomically: a run killed while writing leaves the previous epoch's checkpoint whole."""
+    p = Path(path); p.parent.mkdir(parents=True, exist_ok=True); tmp = p.with_name(p.name + ".tmp")
+    model_io.torch_save(obj, tmp); tmp.replace(p)
+
+
 def train_fly(ds: DecisionSet, rows: np.ndarray, teacher, epochs: int = EPOCHS, batch: int = BATCH, stop: threading.Event | None = None,
               seed: int = 0, graph=None, device=None, net_kwargs: dict | None = None, model_cls=None, target_clip: tuple = (-1.0, 1.0),
-              horizon_min: int | None = None) -> tuple[FlyModel | None, dict]:
+              horizon_min: int | None = None, checkpoint=None) -> tuple[FlyModel | None, dict]:
     """Distil ``teacher`` (a StackTeacher, or anything with ``score`` and ``scaler``) into a FlyNet over the training rows
     ``rows`` (mask): one head per strategy, each learning its strategy's targets on that strategy's candidates.
     ``net_kwargs`` (``aff_rows``, ``scale``), ``model_cls`` and ``target_clip`` let another trading type (kalshi/fly.py) run
-    its own fly through this loop; the memecoin defaults are unchanged."""
+    its own fly through this loop; the memecoin defaults are unchanged. ``checkpoint``: a file written after every epoch
+    (weights, optimiser, history, the best epoch so far, the random state): a run that dies resumes after its last
+    finished epoch, and a finished one goes on past the cap it ran under when ``epochs`` is raised. A file written for
+    other training data is set aside, never resumed."""
     brain_device.seed_all(seed); rng = np.random.default_rng(seed); dev = torch.device(device) if device else _device()
     n_s = len(teacher.strategies) if isinstance(teacher, StackTeacher) else 1
     net = FlyNet(graph if graph is not None else _graph(), obs_dim=len(ds.cols), device=dev, n_strategies=n_s, **(net_kwargs or {}))
@@ -451,8 +477,18 @@ def train_fly(ds: DecisionSet, rows: np.ndarray, teacher, epochs: int = EPOCHS,
             col = T[:, j]; hd.bias.fill_(float(np.nanmean(col)) * net.scale if np.isfinite(col).any() else 0.0); hd.weight.mul_(0.1)
     batch = min(batch, net.batch_rows(ceiling=batch, training=True))      # a training step keeps every propagation step: ~4x a forward pass
     opt = torch.optim.Adam(net.param_groups(LR_GRAPH, LR_HEAD)); n_b = max(1, len(use) // batch); total = max(1, epochs * n_b); hist = []; t0 = time.time()
-    best = best_v = prev_v = early = None
-    for ep in range(epochs):
+    best = best_v = prev_v = early = None; start = 0
+    fp = {"training_rows": int(len(idx)), "rows": int(len(use)), "val_rows": int(len(val)), "seed": int(seed), "obs_dim": int(len(ds.cols)),
+          "strategies": list(teacher.strategies) if isinstance(teacher, StackTeacher) else []}
+    ck = _resume(checkpoint, fp) if checkpoint is not None else None
+    if ck is not None:
+        net.load_state_dict(ck["state_dict"])
+        if ck.get("opt") is not None:
+            opt.load_state_dict(ck["opt"])
+        if ck.get("rng") is not None:
+            rng.bit_generator.state = ck["rng"]
+        hist, best, best_v, prev_v, early, start = list(ck["hist"]), ck.get("best"), ck.get("best_v"), ck.get("prev_v"), ck.get("early"), int(ck["epoch"]) + 1
+    for ep in range(start, epochs if early is None else start):
         perm = use[rng.permutation(len(use))]; tot = 0.0; net.train()
         for b in range(n_b):
             if stop is not None and stop.is_set():
@@ -464,24 +500,27 @@ def train_fly(ds: DecisionSet, rows: np.ndarray, teacher, epochs: int = EPOCHS,
             loss = (w * (net.forward_all(x) - t) ** 2).sum() / w.sum().clamp(min=1e-9)
             opt.zero_grad(); loss.backward(); torch.nn.utils.clip_grad_norm_(net.parameters(), 5.0); opt.step(); tot += loss.item()
             if b % 200 == 0:
-                done = ep * n_b + b + 1; el = time.time() - t0
-                prog.update("fly: learning from the selector", done, total, epoch=ep, loss=tot / (b + 1), rows_per_s=done * batch / max(el, 1e-9),
-                            eta_s=(total - done) * el / done)
+                done = ep * n_b + b + 1; here = (ep - start) * n_b + b + 1; el = time.time() - t0      # ``here``: this run's steps (a resumed run's rate)
+                prog.update("fly: learning from the selector", done, total, epoch=ep, loss=tot / (b + 1), rows_per_s=here * batch / max(el, 1e-9),
+                            eta_s=(total - done) * el / here)
         hist.append({"epoch": ep, "mse": tot / n_b, "secs": time.time() - t0, "rows": min(len(use), n_b * batch)})
         log.info("fly epoch %d: weighted mse %.4f over %d rows (%.0fs)", ep, tot / n_b, min(len(use), n_b * batch), time.time() - t0)
-        if not len(val):
-            continue
-        vm, vse = _val_mse(net, teacher.scaler, ds, idx, T, W, val, dev, batch)
-        hist[-1]["val_mse"], hist[-1]["val_se"] = vm, vse
-        log.info("fly epoch %d: held-out weighted mse %.4f +/- %.4f over %d rows", ep, vm, vse, len(val))
-        if best_v is None or vm < best_v:
-            best_v, best = vm, {k: v.detach().clone() for k, v in net.state_dict().items()}
-        gain = None if prev_v is None else prev_v - vm
-        stop_now = ep + 1 >= MIN_EPOCHS and gain is not None and gain <= vse
-        prev_v = vm
-        if stop_now:
-            early = f"epoch {ep} moved the held-out error by {gain:+.4f}, inside its standard error {vse:.4f}"
-            log.info("fly: stopping early - %s", early)
+        if len(val):
+            vm, vse = _val_mse(net, teacher.scaler, ds, idx, T, W, val, dev, batch)
+            hist[-1]["val_mse"], hist[-1]["val_se"] = vm, vse
+            log.info("fly epoch %d: held-out weighted mse %.4f +/- %.4f over %d rows", ep, vm, vse, len(val))
+            if best_v is None or vm < best_v:
+                best_v, best = vm, {k: v.detach().clone() for k, v in net.state_dict().items()}
+            gain = None if prev_v is None else prev_v - vm
+            stop_now = ep + 1 >= MIN_EPOCHS and gain is not None and gain <= vse
+            prev_v = vm
+            if stop_now:
+                early = f"epoch {ep} moved the held-out error by {gain:+.4f}, inside its standard error {vse:.4f}"
+                log.info("fly: stopping early - %s", early)
+        if checkpoint is not None:
+            _write_checkpoint(checkpoint, {"fingerprint": fp, "epoch": ep, "state_dict": net.state_dict(), "opt": opt.state_dict(), "best": best,
+                                           "best_v": best_v, "prev_v": prev_v, "hist": hist, "rng": rng.bit_generator.state, "early": early})
+        if early is not None:
             break
     if best is not None:
         net.load_state_dict(best)                          # the epoch that generalised best, not merely the last one
@@ -617,12 +656,13 @@ def fly_decide(fly: FlyModel, X: np.ndarray, cols: list[str], values: np.ndarray
 
 
 def bootstrap(ds: DecisionSet, S: date, epochs: int = EPOCHS, stop: threading.Event | None = None, seed: int = 0, graph=None,
-              device=None, teacher=None, teacher_note: str | None = None) -> tuple[FlyModel | None, dict]:
+              device=None, teacher=None, teacher_note: str | None = None, checkpoint=None) -> tuple[FlyModel | None, dict]:
     """The one time the selector teaches: a fly ready to trade from day ``S`` on, with its own line and sizing per strategy.
     ``teacher``: the live path passes the deployed selector (``deployed_teacher``); left None, the stack is refit on the
     days before ``S − 8`` — which is what the replay wants, since there the refit is the honest out-of-sample teacher (a
     set without the stack's inputs or per-hold labels — synthetic tests — gets the single-model selector).
-    ``teacher_note`` records in the snapshot which selector taught this fly."""
+    ``teacher_note`` records in the snapshot which selector taught this fly. ``checkpoint``: the training's per-epoch
+    checkpoint file (``train_fly``)."""
     from .decisions import LEGACY_COLS
     train_end = S - timedelta(days=CALIB_DAYS + PURGE_DAYS)
     train = ds.day < train_end; uni = selector.in_universe(ds.X, ds.cols)
@@ -638,7 +678,7 @@ def bootstrap(ds: DecisionSet, S: date, epochs: int = EPOCHS, stop: threading.Ev
                 return None, {"S": str(S), "gates_ok": False, "gate_failures": ["the teacher stack has no strategy on the training days"], "teacher_stack": stack_info}
         else:
             teacher = selector.fit(ds, train, seed=7)
-    fly, fit_info = train_fly(ds, train & uni, teacher, epochs=epochs, stop=stop, seed=seed, graph=graph, device=device)
+    fly, fit_info = train_fly(ds, train & uni, teacher, epochs=epochs, stop=stop, seed=seed, graph=graph, device=device, checkpoint=checkpoint)
     if fly is None:
         return None, {"stopped": True, **fit_info}
     s_epoch = datetime(S.year, S.month, S.day, tzinfo=timezone.utc).timestamp()
@@ -695,16 +735,23 @@ def teacher_scores(models: dict, X: np.ndarray, ts, names: list[str], cols: list
     X = np.atleast_2d(X); out = np.full((len(X), len(names)), np.nan)
     tsa = np.broadcast_to(np.asarray(ts, dtype=np.float64), (len(X),))
     for i in range(0, len(X), chunk):
-        per = strategies.decide_all(models, X[i:i + chunk], cols, tsa[i:i + chunk])
-        for j, k in enumerate(names):
-            if k in per:
-                sc = per[k]["score"]
-                out[i:i + chunk, j] = np.where(per[k]["trig"] & np.isfinite(sc), np.clip(sc, -1.0, 1.0), np.nan)
+        out[i:i + chunk] = teacher_scores_of(strategies.decide_all(models, X[i:i + chunk], cols, tsa[i:i + chunk]), names, len(X[i:i + chunk]))
+    return out
+
+
+def teacher_scores_of(per: dict, names: list[str], n: int) -> np.ndarray:
+    """``teacher_scores`` of ``n`` rows from the stack's ``strategies.decide_all`` result on them (no second pass)."""
+    out = np.full((n, len(names)), np.nan)
+    for j, k in enumerate(names):
+        if k in per:
+            sc = per[k]["score"]
+            out[:, j] = np.where(per[k]["trig"] & np.isfinite(sc), np.clip(sc, -1.0, 1.0), np.nan)
     return out
 
 
 def is_current(meta: dict | None, version: dict | None = None) -> bool:
-    return bool(meta) and meta.get("data") == (version or FLY_VERSION)
+    """Trained on exactly the current definitions, the retired corpus build versions set aside (``selector.defs_match``)."""
+    return bool(meta) and selector.defs_match(meta.get("data"), version or FLY_VERSION)
 
 
 def save(fly: FlyModel, metrics: dict, run_id: str | None = None, kind: str = "fly_selector", subdir: str = "policies", version: dict | None = None,
@@ -750,14 +797,17 @@ def latest_current(conn, kind: str = "fly_selector", version: dict | None = None
 
 
 def deployable(meta: dict | None, version: dict | None = None) -> tuple[bool, str]:
-    """A bootstrap may trade: current definitions, healthy network (``GATES``) and its own line made money over at least
-    100 trades on its calibration week."""
+    """A bootstrap may race for the seat: current definitions, healthy network (``GATES``) and its own line made money on
+    its calibration week over at least the race's own minimum of trades (``config.HANDOVER_MIN_TRADES``). The wallet
+    trades the selector's decisions until the fly wins its race (agent/fly_session.py), so a calibration week need not
+    prove more than the race will: a quiet week (2026-10-15..21) gave a new fly 88 trades, under the 100 asked before.
+    Another trading type (``version``: Kalshi) keeps ``selector.MIN_LINE_TRADES``."""
     if not is_current(meta, version):
         return False, "trained on other definitions"
     if not meta.get("gates_ok"):
         return False, "; ".join(meta.get("gate_failures") or ["network gates failed"])
     cal = meta.get("calibration") or {}
-    if (cal.get("trades") or 0) < selector.MIN_LINE_TRADES:
+    if (cal.get("trades") or 0) < (config.HANDOVER_MIN_TRADES if version in (None, FLY_VERSION) else selector.MIN_LINE_TRADES):
         return False, f"too few calibration trades ({cal.get('trades') or 0})"
     if not (isinstance(cal.get("mean"), (int, float)) and math.isfinite(cal["mean"]) and cal["mean"] > 0):      # NaN never passes
         return False, f"its calibration week lost money ({(cal.get('mean') or 0) * 100:+.2f}% per trade)"
@@ -787,11 +837,12 @@ def main(days: int | None = None, epochs: int | None = None, stop_event: threadi
     ds = build(days=days, horizon_min=HOLD_MIN, holds=HOLDS_MIN); S = ds.days[-1] + timedelta(days=1)
     teacher, note, taught_by = deployed_teacher(ds, ds.day < S - timedelta(days=CALIB_DAYS + PURGE_DAYS), calib_start=S - timedelta(days=CALIB_DAYS))
     log.info("fly bootstrap teacher: %s", note)
-    fly, info = bootstrap(ds, S, epochs=EPOCHS if epochs is None else epochs, stop=stop_event, teacher=teacher, teacher_note=note)
+    fly, info = bootstrap(ds, S, epochs=EPOCHS if epochs is None else epochs, stop=stop_event, teacher=teacher, teacher_note=note, checkpoint=CHECKPOINT)
     if fly is None:
-        return {"stopped": True}
+        return {"stopped": True}                     # its checkpoint stays: the next run on the same data resumes it
     info["teacher_snapshot"] = taught_by
     record_event("info", "fly_selector", "fly bootstrap", {k: info.get(k) for k in ("S", "lines", "calibration", "diagnostics", "gates_ok", "gate_failures", "teacher")})
     path, sid = save(fly, info)
+    CHECKPOINT.unlink(missing_ok=True)
     prog.update("fly: done", 1, 1, force=True, snapshot_id=sid, line=info["line"], gates_ok=info["gates_ok"], diagnostics=info["diagnostics"])
     return {**info, "snapshot_id": sid, "path": str(path)}

fly_trader/train/mature.py

@@ -2,7 +2,10 @@
 as feature rows — the population the live bot actually meets on Jupiter's lists, as opposed to the first 12 hours
 after graduation covered by ``replay_assemble``.
 
-Stage 1 (``aggregate_day``): all ``pump-amm`` trade legs of pump.fun-origin mints (suffix ``pump``, SOL-quoted) of a UTC day,
+Stage 1 (``aggregate_day``): all PumpSwap (``pump-amm``) and Meteora DLMM trade legs (``UNIVERSE_POOLS``: since
+2026-10-23 a coin's DLMM pool competes for its minute like any other pool, and is the only SOL market of a coin graduated
+into a USDC, stock-token or other-coin pool) of pump.fun-origin mints (suffix ``pump``, or a pump.fun graduate without it:
+``corpus_meta.pumpfun_graduates``; SOL-quoted) of a UTC day,
 except legs in pools created directly rather than by a pump.fun migration (``pump_pools``: their owner can pull the unburned
 liquidity, and the withdrawal is not in the trade data, so the price just stops after a pump),
 with causal filters only (the live stream applies the same ones): quote reserve 0.001–100,000 SOL, a leg more than 50× away
@@ -19,7 +22,10 @@ mask as absent), Jupiter stats stay masked. Age and price-vs-graduation come fro
 graduation is inside the archive (``corpus_meta.graduated_at``, the source live uses too); older tokens carry NaN age.
 Output: ``data/corpus/features_mature/<day>/part.parquet``. Both outputs carry a version in their Parquet metadata
 (``AGG_VERSION``, ``market.features.FEATURE_VERSION``); ``loop_once`` rebuilds any file from another version and moves
-the old one to ``data/corpus/_mature_stale/``. Feature parts also record how many of their mints had a known graduation
+the old one to ``data/corpus/_mature_stale/``. ``AGG_VERSION`` only says when the files are rebuilt: it is not a model
+definition (``train/selector.DATA_VERSION``), so a rebuild never retires a model. A rebuild of more than
+``BULK_REBUILD_DAYS`` days runs in a child process at the lowest CPU priority (``loop_once_apart``), never beside the
+console's live minute pipeline. Feature parts also record how many of their mints had a known graduation
 (``fly_known``); a part is rebuilt once ``corpus_meta`` dates more of them (older days are backfilled after newer ones).
 """
 from __future__ import annotations
@@ -29,6 +35,8 @@ import logging
 import math
 import os
 import shutil
+import subprocess
+import sys
 import threading
 import time
 from datetime import date, datetime, timedelta, timezone
@@ -45,14 +53,16 @@ from ..db.connection import transaction
 from ..market.exit_cost import PUMP_SUPPLY
 from ..market.features import FEATURE_VERSION, FIDX, TokenMeta, TokenState
 from .corpus_features import SCHEMA as FEAT_SCHEMA, PRE_COLS, _epoch_s, _row
-from .corpus_meta import blocked_pool_ids
+from .corpus_meta import UNIVERSE_POOLS, blocked_pool_ids, pumpfun_graduates
 from .flow import FLOW_COLS, MARKET_COLS, N_SKILL, SKILL_COLS, UNKNOWN, FlowWindow, MarketWindow
 
 log = logging.getLogger(__name__)
 MATURE_DIR = config.CORPUS_DIR / "mature"
 MATURE_FEAT_DIR = config.CORPUS_DIR / "features_mature"
 STALE_DIR = config.CORPUS_DIR / "_mature_stale"
-AGG_VERSION = 4          # 2: causal price band and per-minute dominant pool; 3: directly created (custom) PumpSwap pools excluded; 4: wallet flow columns (train/flow.py)
+AGG_VERSION = 5          # 2: causal price band and per-minute dominant pool; 3: directly created (custom) PumpSwap pools excluded; 4: wallet flow columns (train/flow.py);
+                         # 5: pump.fun graduates whose mint lacks the "pump" suffix included (corpus_meta.pumpfun_graduates)
+BULK_REBUILD_DAYS = 3    # more stale aggregates than this are rebuilt by a child process at the lowest CPU priority (live money first)
 KNOWN_REBUILD_FRAC, KNOWN_REBUILD_MIN = 0.01, 25     # a part is rebuilt once corpus_meta dates this many more of its mints
 MASKED = ["logsigners_15m", "logsigners_1h", "hawkes", "log_since_last", "vpin_15m"]
 EXTRA = ["traders_15m", "traders_1h", "n_trades_1m"] + FLOW_COLS + SKILL_COLS + MARKET_COLS
@@ -79,11 +89,21 @@ def _skill_version() -> str:
     return skill_version()
 
 
+def _inputs_newer(p: Path) -> bool:
+    """A day's hour files written after its aggregate: an hour fetched late, or the archive downloaded again
+    (``replay_pull.refetch_main``) to keep more venues' legs."""
+    try:
+        t = p.stat().st_mtime
+        return any(os.path.getmtime(f) > t for f in _hour_files(date.fromisoformat(p.stem)))
+    except (OSError, ValueError):
+        return False
+
+
 def agg_stale(path) -> bool:
-    """An aggregate to rebuild: another aggregation version, or skill buckets from another skill version while its day now
-    has a table of the version in force (days without a table keep 'none')."""
+    """An aggregate to rebuild: another aggregation version, hour files newer than it, or skill buckets from another skill
+    version while its day now has a table of the version in force (days without a table keep 'none')."""
     p = Path(path)
-    if part_version(p) != AGG_VERSION:
+    if part_version(p) != AGG_VERSION or _inputs_newer(p):
         return True
     want = _skill_version()
     return want != "none" and (SKILL_DIR / f"{p.stem}.parquet").exists() and agg_skill(p) != want
@@ -200,25 +220,30 @@ def days_ready() -> list[date]:
     return out
 
 
-def aggregate_table(files: list[str], skill, blocked: list[str] | None = None, insiders: dict | None = None) -> pa.Table:
+def aggregate_table(files: list[str], skill, blocked: list[str] | None = None, insiders: dict | None = None, grads: list[str] | None = None) -> pa.Table:
     """A day's minute aggregates from its hour files, with ``skill`` (wallet → decile table, or None) as the day's skill
     table — ``aggregate_day``'s SQL, also used to rebuild the skill inputs under a candidate table (train/wallet_skill.fit).
-    ``blocked`` (pool ids) and ``insiders`` (mint -> wallets) are read from Postgres when not given; a caller that aggregates
-    many days hands them in once, rather than opening two connections per day."""
+    ``blocked`` (pool ids), ``insiders`` (mint -> wallets) and ``grads`` (pump.fun graduates without the ``pump`` suffix)
+    are read from Postgres when not given; a caller that aggregates many days hands them in once, rather than opening
+    connections per day."""
     con = duckdb.connect()
     cols = [c[0] for c in con.execute("SELECT * FROM read_parquet(?, union_by_name = true) LIMIT 0", [files]).description]
     quote_filter = "AND (quote_mint IS NULL OR quote_mint = 'So11111111111111111111111111111111111111112')" if "quote_mint" in cols else ""
     pool_sel = "pool_id" if "pool_id" in cols else "NULL AS pool_id"
-    if blocked is None:
+    if blocked is None or grads is None:
         with transaction() as conn:
-            blocked = blocked_pool_ids(conn)
+            blocked = blocked_pool_ids(conn) if blocked is None else blocked
+            grads = pumpfun_graduates(conn) if grads is None else grads
     con.register("blocked", pa.table({"pool_id": pa.array(blocked, pa.string())}))
+    con.register("grads", pa.table({"mint": pa.array(grads, pa.string())}))
     pool_filter = "AND (pool_id IS NULL OR pool_id NOT IN (SELECT pool_id FROM blocked))" if "pool_id" in cols else ""
     # causal filters only (nothing later in the day decides which earlier trades exist); the live stream applies the same:
-    # no directly created pool, reserve band, a leg within 50x of the median of the mint's previous 200 legs, and per (mint, minute) the pool with the most legs
+    # pump.fun's coins only, no directly created pool, reserve band, a leg within 50x of the median of the mint's previous 200 legs,
+    # and per (mint, minute) the pool with the most legs
     con.execute(f"""CREATE TEMP TABLE raw AS SELECT mint, ts, slot, trader, side, sol, price, quote_in_pool, {pool_sel}
                     FROM read_parquet(?, union_by_name = true)
-                    WHERE pool = 'pump-amm' AND price > 0 AND mint LIKE '%pump' AND quote_in_pool BETWEEN 0.001 AND 100000 {quote_filter} {pool_filter}""", [files])
+                    WHERE pool IN ({", ".join(f"'{x}'" for x in UNIVERSE_POOLS)}) AND price > 0 AND (mint LIKE '%pump' OR mint IN (SELECT mint FROM grads))
+                      AND quote_in_pool BETWEEN 0.001 AND 100000 {quote_filter} {pool_filter}""", [files])
     con.execute("""CREATE TEMP TABLE banded AS SELECT * EXCLUDE (pref) FROM (
                       SELECT *, median(price) OVER (PARTITION BY mint ORDER BY ts, slot ROWS BETWEEN 200 PRECEDING AND 1 PRECEDING) AS pref FROM raw)
                     WHERE pref IS NULL OR price BETWEEN pref / 50 AND pref * 50""")
@@ -260,7 +285,8 @@ def aggregate_table(files: list[str], skill, blocked: list[str] | None = None, i
     return tab
 
 
-def aggregate_day(d: date) -> int:
+def aggregate_day(d: date, blocked: list[str] | None = None, grads: list[str] | None = None) -> int:
+    """Aggregate day ``d`` (``aggregate_table``); ``blocked`` and ``grads`` as there, read here when not given."""
     t0 = time.time(); files = _hour_files(d)
     if not files:
         return 0
@@ -269,7 +295,7 @@ def aggregate_day(d: date) -> int:
         return 0
     MATURE_DIR.mkdir(parents=True, exist_ok=True)
     skill = skill_table_for(d)
-    tab = aggregate_table(files, skill)
+    tab = aggregate_table(files, skill, blocked=blocked, grads=grads)
     write_part(tab, MATURE_DIR / f"{d.isoformat()}.parquet", AGG_VERSION, {"fly_skill": _skill_version() if skill is not None else "none"})
     n_mints = len(pa.compute.unique(tab["mint"]))
     with transaction() as conn:
@@ -386,6 +412,46 @@ def _knows_more(part: Path, grads: dict) -> bool:
     return grew >= max(KNOWN_REBUILD_MIN, KNOWN_REBUILD_FRAC * len(mints))
 
 
+def stale_aggregates() -> list[Path]:
+    """Aggregates the next round rebuilds: another aggregation (or skill) version, with their hour files at hand."""
+    return [f for f in sorted(MATURE_DIR.glob("*.parquet")) if agg_stale(f) and _hour_files(date.fromisoformat(f.stem))]
+
+
+def loop_once_apart(stop_event: threading.Event | None = None) -> int | None:
+    """One build round in a child process (``fly-trader build-mature``) at the lowest CPU priority, waited for. A version
+    change re-aggregates and re-features every day (~100 s a day, ~5 h for the whole archive): that work must not share the
+    console's interpreter with the live minute pipeline (CLAUDE.md, live money first). On stop the child is ended; every
+    file is written atomically, so an ended round loses only its unfinished day. Its exit code, or None when stopped."""
+    nice = ["/usr/bin/nice", "-n", "19"] if os.path.exists("/usr/bin/nice") else []      # not preexec_fn: unsafe in a threaded process
+    proc = subprocess.Popen([*nice, sys.executable, "-m", "fly_trader", "build-mature"], stdout=subprocess.DEVNULL)
+    log.info("mature build: %d stale day(s), rebuilt by child process %d at the lowest CPU priority", len(stale_aggregates()), proc.pid)
+    while proc.poll() is None:
+        if stop_event is not None and stop_event.is_set():
+            proc.terminate()
+            try:
+                proc.wait(timeout=30)
+            except subprocess.TimeoutExpired:
+                proc.kill()
+            log.info("mature build child %d ended on stop", proc.pid)
+            return None
+        time.sleep(2.0)
+    if proc.returncode:
+        log.warning("mature build child %d exited %d (its log: replay.log)", proc.pid, proc.returncode)
+    return proc.returncode
+
+
+def try_loop_once() -> int | None:
+    """``loop_once`` unless another process holds the build lock (then None at once): the archive refetch rebuilds the
+    days it rewrote without waiting hours behind a rebuild that will see them anyway."""
+    MATURE_DIR.mkdir(parents=True, exist_ok=True)
+    with open(MATURE_DIR / ".build.lock", "w") as lock:
+        try:
+            fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB)
+        except BlockingIOError:
+            return None
+        return _loop_once()
+
+
 def loop_once() -> int:
     """One build round. A file lock serialises rounds across processes (the console's replay worker and the CLI)."""
     MATURE_DIR.mkdir(parents=True, exist_ok=True)
@@ -407,8 +473,12 @@ def _loop_once() -> int:
                 _retire(MATURE_FEAT_DIR / dd.isoformat() / "part.parquet", f"feat_{dd}")
             with transaction() as conn:
                 conn.execute("DELETE FROM mature_days WHERE day = %s", (d,))
-    for d in days_ready():
-        aggregate_day(d); n += 1
+    days = days_ready()
+    if days:
+        with transaction() as conn:                 # the custom pools and suffix-less graduates once a round, not once a day
+            blocked, pf = blocked_pool_ids(conn), pumpfun_graduates(conn)
+        for d in days:
+            aggregate_day(d, blocked=blocked, grads=pf); n += 1
     grads = _graduations()          # corpus_meta.rebuild reads the day's events before every round, so its graduations are known
     for f in sorted(MATURE_DIR.glob("*.parquet"), reverse=True):
         d = date.fromisoformat(f.stem)

fly_trader/train/replay_assemble.py

@@ -77,7 +77,7 @@ def assemble_day(d: date) -> tuple[int, int]:
     t0 = time.time(); nxt = d + timedelta(days=1)
     con = duckdb.connect()
     ev_files = _files(d, "events", range(24))
-    grads = con.execute("SELECT mint, min(ts) AS g, arg_min(slot, ts) AS slot, arg_min(quote_in_pool, ts) AS rq0 FROM read_parquet(?) "
+    grads = con.execute("SELECT mint, min(ts) AS g, arg_min(slot, ts) AS slot, arg_min(quote_in_pool, ts) AS rq0 FROM read_parquet(?, union_by_name = true) "
                         "WHERE action = 'migrate' AND pool = 'pump-amm' AND mint IS NOT NULL GROUP BY mint", [ev_files]).fetchall()
     if not grads:
         return 0, 0
@@ -87,8 +87,9 @@ def assemble_day(d: date) -> tuple[int, int]:
                 [v for g in grads for v in (g[0], g[1])])
     # every trade leg of a graduated mint within [g − 30 min, g + 36 h]
     con.execute("CREATE TEMP TABLE tr0 AS SELECT t.mint, t.ts, t.slot, t.pool, t.trader, t.side, t.sol, t.tokens, t.price, t.quote_in_pool, "
-                "epoch_ms(t.ts) - epoch_ms(g.g) AS rel_ms FROM read_parquet(?) t JOIN grads g USING (mint) "
-                "WHERE t.ts >= g.g - INTERVAL 30 MINUTE AND t.ts < g.g + INTERVAL 36 HOUR AND t.price > 0 "
+                "epoch_ms(t.ts) - epoch_ms(g.g) AS rel_ms FROM read_parquet(?, union_by_name = true) t JOIN grads g USING (mint) "
+                "WHERE t.pool IN ('pump', 'pump-amm') "          # the hour files also keep other venues' SOL legs since 2026-10-23
+                "AND t.ts >= g.g - INTERVAL 30 MINUTE AND t.ts < g.g + INTERVAL 36 HOUR AND t.price > 0 "
                 "AND (t.pool = 'pump' OR t.quote_in_pool BETWEEN 0.001 AND 100000)", [tr_files])
     band_amm(con, "tr0", "tr")
     (cdir := config.CORPUS_DIR / "candles").mkdir(parents=True, exist_ok=True); (tdir := config.CORPUS_DIR / "trades").mkdir(parents=True, exist_ok=True)
@@ -162,7 +163,10 @@ def assemble_loop(stop_event: threading.Event | None = None, idle_s: float = 60.
                 log.exception("corpus_meta rebuild failed; mature build waits for the next round")
             else:
                 try:
-                    mature.loop_once()
+                    if len(mature.stale_aggregates()) > mature.BULK_REBUILD_DAYS:
+                        mature.loop_once_apart(stop_event)          # a version change's rebuild: hours of work, kept out of the console
+                    else:
+                        mature.loop_once()
                 except Exception:
                     log.exception("mature universe build failed")
         end = time.time() + idle_s

fly_trader/train/selector.py

@@ -39,32 +39,33 @@ from ..db.connection import transaction
 from ..market.features import FEATURE_VERSION
 from . import model_io, progress as prog
 from .decisions import HOLD_MIN, MIN_RESQ_SOL, MIN_VOL_15M_SOL, X_COLS, DecisionSet, build, evaluate, random_trades, rank_corr, summarize, taken_rows
-from .mature import AGG_VERSION
 from .scaling import RobustScaler
 
 log = logging.getLogger(__name__)
 SELECTOR_DIR = config.BRAIN_DIR / "selectors"
 # the data and model definitions a selector was trained on (the input columns by hash, so dropping or adding one retires
 # old models); a model from other definitions is never loaded or shown. The fly has its own (train/fly_selector.FLY_VERSION),
-# so a change to the fly never retires a selector.
+# so a change to the fly never retires a selector. The corpus build versions (mature.AGG_VERSION, rh/corpus.RH_AGG_VERSION)
+# are not definitions: they say when the corpus files are rebuilt (which tokens and legs a day holds), not what a model's
+# inputs, labels or costs mean, so a rebuild never retires a model (until 2026-10-23 they were keys here, and widening the
+# universe to data already in the corpus would have stopped all trading until a retrain).
 def _skill_version() -> str:
     from .wallet_skill import skill_version
     return skill_version()
 
 
 def _rh_version() -> dict:
-    """The Robinhood Chain half of the combined dataset: its aggregation, skill space and cost constants (a model trained
-    before RH rows existed, or on other RH definitions, is not current). Not RH_ENABLED: whether an install indexes and
+    """The Robinhood Chain half of the combined dataset: its skill space and cost constants (a model trained before RH
+    rows existed, or on other RH definitions, is not current). Not RH_ENABLED: whether an install indexes and
     trades RH is its own choice, and a combined model trades Solana alone (until 2026-10-10 an install with RH off
     computed "chains": "sol", refused the shipped combined models and crash-looped at boot)."""
     from .. import config
-    from ..rh.corpus import RH_AGG_VERSION
     from ..rh.wallet_skill import skill_version as rh_skill
-    return {"chains": "sol+rh-1", "rh_agg": RH_AGG_VERSION, "rh_skill": rh_skill(),
+    return {"chains": "sol+rh-1", "rh_skill": rh_skill(),
             "rh_costs": f"pons-kyber-1:{config.RH_ETH_PER_SOL:g}:{config.RH_LABEL_SIZE_ETH:g}:{config.RH_TX_FEE_ETH:g}:{config.RH_HOOK_FEE:g}"}
 
 
-DATA_VERSION = {"agg": AGG_VERSION, "features": FEATURE_VERSION, "costs": "real-fees-sized-1", "selector": "multi-1",
+DATA_VERSION = {"features": FEATURE_VERSION, "costs": "real-fees-sized-1", "selector": "multi-1",
                 "cols": hashlib.sha1(",".join(X_COLS).encode()).hexdigest()[:8], "skill": _skill_version(), "meta": "rug-1", **_rh_version()}
 WARMUP_DAYS, BLOCK_DAYS = 21, 7      # walk-forward: the first 21 days only train; every later day is tested, refit every 7 days
 MIN_AGE_H = 6.0                      # trade only tokens at least this long past graduation (unknown age = graduated before the archive); fitted, see decisions.HOLD_MIN
@@ -81,9 +82,21 @@ def in_universe(X: np.ndarray, cols: list[str]) -> np.ndarray:
     return (X[:, c["age_known"]] == 0) | (np.expm1(X[:, c["log_age_h"]]) >= MIN_AGE_H)
 
 
+RETIRED_KEYS = ("agg", "rh_agg")     # the corpus build versions, dropped from the definitions 2026-10-23
+
+
+def defs_match(stored, current: dict) -> bool:
+    """A stored definitions record (a fly's or a replay verdict's ``data``) equals ``current`` once the keys retired from the
+    definitions (``RETIRED_KEYS``, when ``current`` no longer has them) are set aside. Retiring a key never retires a fly;
+    every other difference still does, an extra key included (a distilled fly's ``distil`` keeps it out)."""
+    if not isinstance(stored, dict):
+        return False
+    return {k: v for k, v in stored.items() if k in current or k not in RETIRED_KEYS} == current
+
+
 def is_current(meta: dict | None) -> bool:
     """Trained on every definition in ``DATA_VERSION``. Keys a model carries that are no longer definitions (the fly's,
-    which moved to ``FLY_VERSION``) are ignored; a model saved before the column hash existed is judged on the rest."""
+    which moved to ``FLY_VERSION``; the corpus build versions) are ignored; a model saved before the column hash existed is judged on the rest."""
     d = (meta or {}).get("data")
     return bool(meta) and isinstance(d, dict) and all(d.get(k) == v for k, v in DATA_VERSION.items() if k != "cols" or "cols" in d)
 

fly_trader/train/strategies.py

@@ -18,15 +18,18 @@ hold, its own line):
 - ``breakout``: organic buying pressure at a new high (org_imb_5m > 0, buyers_slope > 0, at the 1 h or 3 h high);
   thresholds on organic imbalance, buyer growth and organic volume (order-flow and attention evidence, wash removed).
 A per-strategy classifier of P(net return > 0), trained only on that strategy's out-of-sample candidates (nested
-walk-forward; the primary score is one of its inputs), filters trades (Joubert 2022 meta-labeling). A multiclass
+walk-forward; the primary score is one of its inputs), filters trades (Joubert 2022 meta-labeling): at the strategy's
+own line it chooses only its cut-off, which must beat no cut-off at all. A multiclass
 GBM of the loss tail gives P(return ≤ d) for dump levels d at tail quantiles of the selection half's pick returns
 and vetoes buys (MemeTrans/MELT: rug risk). Hours and market-volume deciles whose selection-half profit factor is below 1
-are blocked. Where several strategies fire on a token-minute, the one with the larger measured Kelly fraction (its
-sizing band) or the higher score wins — whichever rule made more on the selection half.
+are blocked. The book keeps the passed strategies, and the rule between them, that together score best on the selection
+half: a strategy the book does better without is dropped there. Where several of its strategies fire on a token-minute,
+the one with the larger measured Kelly fraction (its sizing band) or the higher score wins.
 """
 from __future__ import annotations
 
 import hashlib
+import itertools
 import logging
 import threading
 from dataclasses import dataclass, field
@@ -188,9 +191,10 @@ def beats_random_removal(ds: DecisionSet, pick_before: np.ndarray, pick_after: n
 
 # ---------------------------------------------------------------- walk-forward primitives
 def _cache_path(ds: DecisionSet, cols: list[str], tag: str) -> "Path":
+    from .mature import AGG_VERSION
     from .selector import DATA_VERSION
-    k = repr((str(ds.days[0]), str(ds.days[-1]), int(len(ds.y)), float(ds.horizon_s), list(cols), tag,
-              DATA_VERSION.get("agg"), DATA_VERSION.get("features"), DATA_VERSION.get("costs"), OBJECTIVE)
+    k = repr((str(ds.days[0]), str(ds.days[-1]), int(len(ds.y)), float(ds.horizon_s), list(cols), tag,          # the corpus build version keys
+              AGG_VERSION, DATA_VERSION.get("features"), DATA_VERSION.get("costs"), OBJECTIVE)                    # the cache, not the model's validity
              + (("label-known-purge",) if getattr(ds, "label_ts", None) is not None else ())
              + ((("data", getattr(ds, "data_version")),) if getattr(ds, "data_version", None) is not None else ())     # e.g. the Kalshi feature version
              + ((("train_max_rows", int(getattr(ds, "train_max_rows"))),) if getattr(ds, "train_max_rows", None) else ()))
@@ -456,32 +460,32 @@ def fit_strategy(ds: DecisionSet, name: str, cols: list[str], uni: np.ndarray, s
 
 # ---------------------------------------------------------------- meta-label, veto, gates
 def fit_meta(ds: DecisionSet, s: StrategyFit, uni: np.ndarray, sel: np.ndarray, day0, stop=None) -> tuple[np.ndarray, float | None, dict]:
-    sp = s.spec or memecoin_spec()
     """Nested: a classifier of P(net return > 0 over the strategy's hold) on its OOS candidates (primary score ≥ 0 and
-    the fitted trigger), walk-forward, the primary score among its inputs; the cut-off (deciles among the selection
-    half's candidates) jointly with the line."""
+    the fitted trigger), walk-forward, the primary score among its inputs; then its cut-off at the strategy's own line
+    (deciles among the selection half's trades), against no cut-off at all. Until 2026-10-19 the line was chosen jointly
+    with the cut-off: on selector #154 that moved ev's line from 0.038 to 0.115, and the filter priced the strategy out of
+    the book instead of filtering it. ``cut`` None: no cut-off cleared the bars, or trading without one did better
+    (``info["unfiltered"]``)."""
+    sp = s.spec or memecoin_spec()
     X, c = ds.X, ds.cols; ci = np.asarray([c.index(x) for x in s.cols]); y_r = sp.label(ds, s.hold_min)
     rows = uni & sp.base_mask(s.name, X, c, s.high) & trigger_mask(s.name, s.thr, X, c, sp) & np.isfinite(s.oos) & (s.oos >= 0) & np.isfinite(y_r)
     log.info("meta-label %s: %d candidate rows of %d, %d inputs, hold %d min", s.name, int(rows.sum()), len(ds.y), len(ci) + 1, s.hold_min)
     feats = lambda idx: np.c_[X[np.ix_(idx, ci)], s.oos[idx]]
     p = wf_classify(ds, rows, feats, (y_r > 0).astype(np.int8), 2, stop)[:, 1]
-    log.info("meta-label %s: classifiers done, %.1f GB resident; choosing the line and cut-off", s.name, _rss_gb())
-    best = None; best_p = None; trials = 0; seen = None
-    lines = [s.line] + quantile_grid(s.oos[sel & rows]); cuts = quantile_grid(p[sel & rows])
-    log.info("meta-label %s: %d lines x %d cut-offs to try", s.name, len(lines), len(cuts))
-    for line in lines:
-        for cut in cuts:
-            trials += 1
-            if trials % 25 == 0:
-                log.info("meta-label %s: trial %d/%d, %.1f GB resident", s.name, trials, len(lines) * len(cuts), _rss_gb())
-            pk = sel & rows & (s.oos >= line) & (p >= cut)
-            sc = score_pick(ds, pk, sp.hold_s(ds, s.hold_min), y_r, day0)
-            if sc.n > 0 and (seen is None or sc.total > seen.total):
-                seen = sc                                     # the most profitable cut-off that actually traded
-            if better(sc, best):
-                best = sc; best_p = (line, cut)
-    return p, (best_p[1] if best_p else None), {"line": best_p[0] if best_p else None, "selection": best.dict() if best else None, "trials": trials,
-                                                "best_seen": seen.dict() if seen else None}
+    log.info("meta-label %s: classifiers done, %.1f GB resident; choosing the cut-off", s.name, _rss_gb())
+    trade = sel & rows & (s.oos >= s.line) & np.isfinite(p)     # its trades where a classifier existed: every trial on the same rows
+    best = None; best_cut = None; trials = 0; seen = None
+    cuts = [None] + quantile_grid(p[trade])                     # no cut-off first: a cut-off must beat it outright
+    log.info("meta-label %s: %d cut-offs to try at its line %.4f", s.name, len(cuts), s.line)
+    for cut in cuts:
+        trials += 1
+        sc = score_pick(ds, trade if cut is None else trade & (p >= cut), sp.hold_s(ds, s.hold_min), y_r, day0)
+        if sc.n > 0 and (seen is None or sc.total > seen.total):
+            seen = sc                                           # the most profitable cut-off that actually traded
+        if better(sc, best):
+            best = sc; best_cut = cut
+    return p, best_cut, {"selection": best.dict() if best else None, "trials": trials, "best_seen": seen.dict() if seen else None,
+                         "unfiltered": best is not None and best_cut is None}
 
 
 def system_pick(ds: DecisionSet, fits: list[StrategyFit], rows: np.ndarray, uni: np.ndarray, combine: str, tables: dict | None = None):
@@ -559,6 +563,15 @@ def _comp(name, passed, reason, sel=None, ev=None, params=None, trials=0, best=N
     return c
 
 
+def _dropped(best: Score, with_it: Score) -> str:
+    """Why the book left a strategy out: the chosen book, which lacks it, beat every book that had it on the selection half."""
+    if best.admissible and not with_it.admissible:
+        return f"dropped from the book: without it the book meets {bars(best.gate)} on the selection half, with it never"
+    if best.base_ok and not with_it.base_ok:
+        return "dropped from the book: every book with it missed the bars on the selection half"
+    return f"dropped from the book: the book made {best.total:.1f} on the selection half without it, {with_it.total:.1f} at best with it"
+
+
 def fit_stack(ds: DecisionSet, stop: threading.Event | None = None, holdout_days_n: int | None = None, spec: "StackSpec | None" = None) -> Stack:
     """Every component in order, each on top of the accepted ones; see the module docstring. ``holdout_days_n``: how many
     of the last days to withhold from every fit (default ``HOLDOUT_DAYS``). A caller whose ``ds`` is already restricted to
@@ -639,22 +652,45 @@ def fit_stack(ds: DecisionSet, stop: threading.Event | None = None, holdout_days
     for f in fits:
         y_r = sp.label(ds, f.hold_min); t = taken_idx(ds.ts, ds.mint, sp.hold_s(ds, f.hold_min), np.flatnonzero(f.pick(ds, sel, uni)))
         tables[f.name] = sizing.build_table(f.oos[t] - f.line, y_r[t])
-    # 3. combination rule
-    best_c = None; combine = "score"
-    for rule in ("kelly", "score"):
-        pk, hd, rt, _ = system_pick(ds, fits, sel, uni, rule, tables)
-        s = score_pick(ds, pk, hd, rt, day0)
-        if better(s, best_c):
-            best_c = s; combine = rule
-    comps.append(_comp("combination", True, f"'{combine}' made more on the selection half", best_c.dict() if best_c else None, None, {"rule": combine}))
-    # 4. meta-label per strategy
+    # 3. the book: which passed strategies it keeps and the rule between them -- every subset under each rule, scored as one
+    # book on the selection half. A strategy the book does better without is dropped here, in the open: until 2026-10-19
+    # only the rule was chosen, logged as having "made more" even when no rule cleared the bars (selector #154), and the
+    # win filter then priced ev out of the book with its line instead.
+    best_c = None; combine = "score"; keep = list(fits); with_it = {}; seen = None; n_books = 0
+    for k in range(len(fits), 0, -1):                              # larger books first: on a tie the book keeps more strategies
+        for sub in itertools.combinations(fits, k):
+            for rule in (("kelly", "score") if k > 1 else ("kelly",)):    # alone, a strategy trades the same rows under either rule
+                n_books += 1
+                s = score_pick(ds, *system_pick(ds, list(sub), sel, uni, rule, tables)[:3], day0)
+                if s.n > 0 and (seen is None or s.total > seen.total):
+                    seen = s
+                for f in sub:                                      # the best book each strategy was part of, for the record
+                    w = with_it.get(f.name)
+                    if w is None or (s.admissible, s.base_ok, s.total) > (w.admissible, w.base_ok, w.total):
+                        with_it[f.name] = s
+                if better(s, best_c):
+                    best_c = s; combine = rule; keep = list(sub)
+    if best_c is None:
+        comps.append(_comp("combination", False, f"no book of the passed strategies cleared the bars on the selection half; all kept under '{combine}'",
+                           params={"rule": combine, "strategies": [f.name for f in fits]}, trials=n_books, best=seen.dict() if seen else None))
+    else:
+        kept = [f.name for f in keep]
+        comps.append(_comp("combination", True, f"{' + '.join(kept)} under '{combine}' made the most on the selection half", best_c.dict(), None,
+                           {"rule": combine, "strategies": kept}, n_books, best=seen.dict() if seen else None))
+        for f in fits:
+            if f.name not in kept:
+                comps.append(_comp(f"combination: {f.name}", False, _dropped(best_c, with_it[f.name]), with_it[f.name].dict(),
+                                   params={"hold_min": f.hold_min, "line": f.line}, best=with_it[f.name].dict()))
+        fits = keep; tables = {n: t for n, t in tables.items() if n in kept}
+    # 4. meta-label per strategy: a filter at the strategy's own line (fit_meta never moves it)
     for f in fits:
         p, cut, info = fit_meta(ds, f, uni, sel, day0, stop)
         if cut is None:
-            comps.append(_comp(f"meta-label: {f.name}", False, "no cut-off cleared the bars on the selection half", trials=info["trials"], best=info.get("best_seen"))); continue
+            comps.append(_comp(f"meta-label: {f.name}", False, "trading without a cut-off did better on the selection half" if info["unfiltered"]
+                               else "no cut-off cleared the bars on the selection half", trials=info["trials"], best=info.get("best_seen"))); continue
         log.info("meta-label %s: scoring the book before the filter (%.1f GB)", f.name, _rss_gb())
         before_s = score_pick(ds, *system_pick(ds, fits, sel, uni, combine, tables)[:3], day0)
-        old = (f.meta_p, f.meta_cut, f.line); f.meta_p, f.meta_cut = p, cut; f.line = info["line"] if info["line"] is not None else f.line
+        old = (f.meta_p, f.meta_cut); f.meta_p, f.meta_cut = p, cut
         log.info("meta-label %s: scoring the book after the filter (%.1f GB)", f.name, _rss_gb())
         after_sel = score_pick(ds, *system_pick(ds, fits, sel, uni, combine, tables)[:3], day0)
         log.info("meta-label %s: evaluation half, unfiltered book (%.1f GB)", f.name, _rss_gb())
@@ -670,7 +706,7 @@ def fit_stack(ds: DecisionSet, stop: threading.Event | None = None, holdout_days
                            else "rejected (selection, evaluation or random-removal test)", after_sel.dict(), {**ev_s.dict(), "random_removal": rnd}, {"cut": cut, "line": f.line},
                            info["trials"], best=info.get("best_seen")))
         if not ok:
-            f.meta_p, f.meta_cut, f.line = old
+            f.meta_p, f.meta_cut = old
     # 5. veto
     veto = None
     pk, hd, rt, who = system_pick(ds, fits, tested, uni, combine, tables)
@@ -710,7 +746,7 @@ def fit_stack(ds: DecisionSet, stop: threading.Event | None = None, holdout_days
 
 def _without_meta(f: StrategyFit, old) -> StrategyFit:
     import copy
-    g = copy.copy(f); g.meta_p, g.meta_cut, g.line = old
+    g = copy.copy(f); g.meta_p, g.meta_cut = old
     return g
 
 
@@ -834,11 +870,12 @@ def decide_all(models: dict, X: np.ndarray, cols: list[str], t_start, spec: "Sta
     return out
 
 
-def decide(models: dict, X: np.ndarray, cols: list[str], t_start, spec: "StackSpec | None" = None) -> dict:
+def decide(models: dict, X: np.ndarray, cols: list[str], t_start, spec: "StackSpec | None" = None, per: dict | None = None) -> dict:
     """The selector's decision for each row of one minute (``t_start`` = the minute's start): which strategy trades it,
-    its predicted net return, hold, line and sizing table, and whether a filter blocks it (with the reason)."""
+    its predicted net return, hold, line and sizing table, and whether a filter blocks it (with the reason). ``per``: this
+    minute's ``decide_all`` when the caller has it already (one pass over the stack)."""
     sp = spec or memecoin_spec()
-    X = np.atleast_2d(X); n = len(X); per = decide_all(models, X, cols, t_start, sp)
+    X = np.atleast_2d(X); n = len(X); per = decide_all(models, X, cols, t_start, sp) if per is None else per
     best_key = np.full(n, -np.inf); strat = np.full(n, None, dtype=object); score = np.full(n, -1.0); hold = np.zeros(n)
     thr = np.full(n, np.inf); tables = [[] for _ in range(n)]; allow = np.zeros(n, bool); reason = np.full(n, "no strategy fires", dtype=object)
     for name, d in per.items():

fly_trader/train/wallet_skill.py

@@ -70,9 +70,18 @@ def build_wallet_day(d: date, out_dir: Path | None = None) -> int:
     if inp is None:
         return 0
     trades, aggs, parts = inp
+    from ..db.connection import transaction
+    from .corpus_meta import pumpfun_graduates
+    with transaction() as conn:
+        grads = pumpfun_graduates(conn)
     con = duckdb.connect()
-    con.execute("""CREATE TEMP TABLE legs AS SELECT mint, trader, ts, side, sol, price FROM read_parquet(?, union_by_name = true)
-                   WHERE pool = 'pump-amm' AND mint LIKE '%pump' AND price > 0 AND sol > 0 AND trader IS NOT NULL""", [trades])
+    con.register("grads", pa.table({"mint": pa.array(grads, pa.string())}))
+    cols = [c[0] for c in con.execute("SELECT * FROM read_parquet(?, union_by_name = true) LIMIT 0", [trades]).description]
+    quote_filter = "AND (quote_mint IS NULL OR quote_mint = 'So11111111111111111111111111111111111111112')" if "quote_mint" in cols else ""
+    # the universe's legs (mature.aggregate_table): pump.fun's coins, SOL-quoted (a leg in another quote is not a SOL amount)
+    con.execute(f"""CREATE TEMP TABLE legs AS SELECT mint, trader, ts, side, sol, price FROM read_parquet(?, union_by_name = true)
+                    WHERE pool IN ({", ".join(f"'{x}'" for x in mature.UNIVERSE_POOLS)}) AND (mint LIKE '%pump' OR mint IN (SELECT mint FROM grads)) AND price > 0 AND sol > 0
+                      AND trader IS NOT NULL {quote_filter}""", [trades])
     con.execute("CREATE TEMP TABLE closes AS SELECT mint, ts AS mts, close FROM read_parquet(?) ORDER BY mint, mts", [aggs])
     con.execute("CREATE TEMP TABLE ec AS SELECT mint, ts AS mts, exit_cost_0p1 AS ec FROM read_parquet(?)", [parts])
     out = []
@@ -177,18 +186,18 @@ def daily() -> int:
     return n
 
 
-def _lookups() -> tuple[list[str], dict]:
-    """The blocked pools and token insiders, read once: a fit aggregates 149 days per candidate, and reconnecting for each
-    one cost thousands of connections and lost a 20-hour run to a connection timeout."""
+def _lookups() -> tuple[list[str], dict, list[str]]:
+    """The blocked pools, token insiders and pump.fun graduates without the suffix, read once: a fit aggregates 149 days per
+    candidate, and reconnecting for each one cost thousands of connections and lost a 20-hour run to a connection timeout."""
     from ..db.connection import transaction
-    from .corpus_meta import blocked_pool_ids
+    from .corpus_meta import blocked_pool_ids, pumpfun_graduates
     with transaction() as conn:
-        blocked = blocked_pool_ids(conn)
+        blocked = blocked_pool_ids(conn); grads = pumpfun_graduates(conn)
         ins: dict = {}
         for r in conn.execute("SELECT mint, wallet FROM token_insiders").fetchall():
             ins.setdefault(r["mint"], []).append(r["wallet"])
-    log.info("wallet skill: %d blocked pools, insiders for %d tokens (read once)", len(blocked), len(ins))
-    return blocked, ins
+    log.info("wallet skill: %d blocked pools, insiders for %d tokens, %d graduates without the suffix (read once)", len(blocked), len(ins), len(grads))
+    return blocked, ins, grads
 
 
 def _day_skill(d: date, h: int, L: int, day_dir: Path | None = None, lookups=None):
@@ -197,8 +206,8 @@ def _day_skill(d: date, h: int, L: int, day_dir: Path | None = None, lookups=Non
     files = mature._hour_files(d)
     if not files or mature._lacks_pool_id(files):
         return None
-    blocked, insiders = lookups if lookups is not None else (None, None)
-    tab = mature.aggregate_table(files, skill_table(d, h, L, day_dir), blocked=blocked, insiders=insiders)
+    blocked, insiders, grads = lookups if lookups is not None else (None, None, None)
+    tab = mature.aggregate_table(files, skill_table(d, h, L, day_dir), blocked=blocked, insiders=insiders, grads=grads)
     sb = np.zeros((tab.num_rows, flow.N_SKILL))
     col = tab["skill_buy"].combine_chunks()
     if col.null_count < len(col):

fly_trader/ui/api/inspector.py

@@ -125,6 +125,20 @@ def _explain_token(latest: list[dict], chain: str) -> str:
     return "\n\n".join(out)
 
 
+def _minute_bar(chain: str, mint: str, at) -> dict | None:
+    """The token's minute at ``at`` (the newest scored minute; None: its newest traded minute): its close and its volume
+    (buys + sells, in its chain's unit), with the close five minutes earlier and the mean volume of the five minutes before
+    it (a minute without trades counts as none) -- the inspector's up/down arrows."""
+    tbl, vol = ("rh_minutes", "COALESCE(buy_eth, 0) + COALESCE(sell_eth, 0)") if chain == "rh" else ("pump_minutes", "COALESCE(buy_sol, 0) + COALESCE(sell_sol, 0)")
+    cur = q1(f"SELECT ts, close, {vol} AS volume FROM {tbl} WHERE mint = %s{' AND ts <= %s' if at else ''} ORDER BY ts DESC LIMIT 1", (mint, at) if at else (mint,))
+    if not cur:
+        return None
+    then = q1(f"SELECT close FROM {tbl} WHERE mint = %s AND ts <= %s - interval '5 minutes' AND close IS NOT NULL ORDER BY ts DESC LIMIT 1", (mint, cur["ts"]))
+    before = q1(f"SELECT sum({vol}) AS v FROM {tbl} WHERE mint = %s AND ts >= %s - interval '5 minutes' AND ts < %s", (mint, cur["ts"], cur["ts"]))
+    return {"ts": cur["ts"], "price": _f(cur["close"]), "volume": _f(cur["volume"]), "price_5m": _f(then["close"]) if then else None,
+            "volume_5m": (_f(before["v"]) or 0.0) / 5.0}
+
+
 @topic("inspector.token", every=10)
 def token(params: dict) -> dict:
     """One memecoin token through the fly's eyes and the books' ledgers."""
@@ -175,7 +189,7 @@ def token(params: dict) -> dict:
     return {"chain": chain, "chain_name": m.name, "unit": m.unit, "mint": mint, "label": labels([mint]).get(mint, mint[:6] + "…"),
             "symbol": meta.get("symbol"), "name": meta.get("name"), "graduated_at": meta.get("graduated_at"), "creator": meta.get("creator"),
             "explorer": explorer(chain, "address", mint), "books": {"selector": m.selector_book, "fly": m.fly_book, "live": m.live_book},
-            "fly_score": config.FLY_SCORE, "teacher_gate": bool(config.FLY_TEACHER_GATE), "learned_veto": config.FLY_LEARNED_VETO,
+            "minute": _minute_bar(chain, mint, last_ts), "fly_score": config.FLY_SCORE, "teacher_gate": bool(config.FLY_TEACHER_GATE), "learned_veto": config.FLY_LEARNED_VETO,
             "series": series, "stats": stats, "total": total, "latest": latest, "explain": _explain_token(latest, chain),
             "decisions": decisions, "positions": positions, "fills": fills,
             "pnl": {"closed": len(closed), "realized": sum(_f(p["realized_sol"]) or 0.0 for p in closed), "open": sum(1 for p in positions if p["status"] == "open"),

models/policies/fly_20261006T023153Z.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:73141bf59bd4321c66f28e4c5a7c83f994adf744574de8b17fe5d3ca94fcc1e7
-size 28525445

models/selectors/selector_20261003T201413Z.skops

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:b38f0633ee4a9b693bfb9a01a5e5de044e2ce317e08fb9726e77b48dfbb603fe
-size 40812282

models/wallet_skill/2026-10-11.parquet

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:34c0faf085f068c217a98d21722aa44a57907b466547f723ffa3fc1e6ee6287c
-size 281123254