Could Jev Be Adapted to Outsmart the Book? (OB‑state quoting, fees & fill)

Read‑only note. No data/CH/HZ touched. Captures the reusable mapping of jev's buildState onto FLIGHT's fill‑prediction lattice (SRC‑01) + the EV gate, so a future session does not re‑derive it.

TL;DR

jev's placement is naive: fixed quoteInsideTicks=1, fixed tradeSizeMon=200, one post‑only order every block regardless of book state. It earns the tick when a taker crosses it and loses the tick‑gas + opportunity cost when it does not.
"Outsmart the book" = predict fill probability from book motion (not the snapshot), gate rest vs take by the EV break‑even, size by the impact‑size curve, and modify‑to‑the‑touch (fee‑free) instead of cancel+place. All of that already exists in FLIGHT.
jev's buildState already assembles the right inputs; the missing piece is a learned fill gate over them. A general structured‑output LLM is the wrong tool — SRC‑01 shows a narrow learned factor lattice (the activity family + EWMA eigen) beats HD and a general LLM, and is far cheaper/faster. jev's value here is the clean state assembly + serialized cadence, not its oracle.

1. jev's book state — what it already sees (`model.ts` buildState)

bookImbalance, spreadBps, depthBps{10/25/50}, top‑5 levels, returnsBps{1/5/20/100} (from a 400‑block mids window), recentMids (every 5th block over horizonBlocks), taker flow summary (cvdMon, vwap, lastSide). The state is OB‑state rich. The placement policy just ignores almost all of it.

2. SRC‑01 (FLIGHT's fill lattice) — what "outsmart" actually means

Source: EXEC_SOA_SUPERSESSION_AUDIT_20260808.md §SRC‑01. Corpus 472 factors / 356,282 rows / 8 assets / base fill rate 0.453 / metric = OOS within‑asset quintile lift (pp).

The activity family dominates everything ("a book that is moving fills you"): n_chg_60 +18.54, q_path_60 +18.21, q_path_30 +17.10, n_chg_30 +16.67, fs_imbalance +16.42, q_range_60 +15.81, q_range_300 +14.98, q_range_15 +14.06, q_range_30 +13.63. Nothing in the OB snapshot comes close.

EWMA bank: eig_ew_w750_lambda_max +11.4 → +12.5 at every span (10…1000) — robust, not an artifact.
|vel_div| (the NG7 incumbent) = +5.02 — beaten 3.7× by the activity family, 2.5× by the EWMA eigen family. Velocity‑only underperforms.
Impact‑size curve peaks at 200–2000 notional, collapses by 50,000. Peak brackets BLUE's actual $16,290 notional — i.e. a resting offer just large enough to be reached by a ~30 s touch.
HD at 39 factors = +20.73 vs best single +19.17 — barely ahead; full 472 killed by memory; verdict OPEN. → a big general model does not pay off here.
New/odd: oi_usd −3.77 (−OI ⇒ more pickup); fewer book levels ⇒ more pickup (thin‑book). Sporadic winner eig_regime_signal +4.72 (z=+15.0, n=32,023) — well‑powered.

jev state → SRC‑01 factor mapping

jev `buildState`	SRC‑01 factor(s)	"outsmart" lever
`returnsBps{1/5/20/100}`, `mids`(400), `recentMids`	`n_chg_60/30`, `q_path_60/30`, `q_range_*`	REST only when book is moving in your direction (p_fill high)
`bookImbalance`, `depthBps{10/25/50}`	`fs_imbalance`, thin‑book effect	pick side where imbalance + thin depth ⇒ higher pickup
(computed) book‑return eigen (EWMA bank)	`eig_ew_w750_lambda_max`	highest‑value add — jev doesn't compute this today
`tradeSizeMon=200` (fixed)	impact‑size curve	SIZE to the curve peak (200–2000 notional); don't sit deep past reachability
`quoteInsideTicks=1` (fixed)	(none — snapshot‑blind)	price inside touch dynamically by p_fill, not by fixed 1 tick
n/a	`oi_usd`	avoid high‑OI windows (reduces pickup)

3. The EV gate that decides rest‑vs‑take (the "avoid fees" hinge)

EV_rest − EV_take = p_fill × (Δ + offset) − (1 − p_fill) × s, break‑even p* = s / (Δ + s). Δ = taker − maker = 4.50 − 1.50 = 3.00 bp (measured, HL mainnet). s = realised cost of a maker miss (delay slippage + adverse drift).

Rest (maker, 1.5 bp rebate / capture the tick) only when p_fill > p*. Below p*, you pay the ~300 ms block gas/wait and likely sit unfilled — that is the fee/opportunity cost jev currently burns every block unconditionally.
jev's replace‑every‑block cancel+place is two signed actions per cycle on Kuru; on HL that erodes the rate budget (HlVenueAdapter 1 req / $1 USDC traded — the #59 ledger). The fee‑free path to "outsmart + avoid fees" is atomic modify‑to‑the‑touch (FLIGHT EntryReprice, same cloid, ≤1/bar) — which jev does NOT have; jev cancel+places.

4. Why a structured‑output LLM is the wrong tool here

The signal is exactly computable: book‑change counts, path/range, imbalance, EWMA eigen — all cheap floats from the depth stream. The study proves a narrow learned lattice (activity family) beats HD and would beat a general LLM, at milliseconds and zero gas.
An LLM per‑cadence call is 50–200 ms of added latency against a venue already budget‑throttled (1 req/$1 USDC) and single‑writer‑lanned (ASEx P0‑P4). It is drag, not thrust.
jev's structured output is rightly confined to the direction call (where BLUE already owns the intent lane) — keep it there. The book‑outsmarting should be a deterministic learned fill gate over jev‑style state.

5. Adaptation recipe (jev's cadence + FLIGHT's gate)

Keep jev's buildState (it is already OB‑state rich) + the serialized post‑only cadence.
Add the activity‑family + EWMA‑eigen features (notably eig_ew_w750_lambda_max, today absent).
Gate rest/take via the EV p* (p_fill > p* → rest; else take or skip) instead of "always rest 1 tick inside."
Size by the impact curve (200–2000 notional peak; BLUE at $16.3k is the upper end of reachability).
Replace cancel+place every block with atomic modify‑to‑the‑touch (FLIGHT EntryReprice, offset_ticks=1, post_only=True) to spare the HL rate budget — this alone is a big fee avoider.
Reuse FLIGHT's ExecControl.max_spread_bps gate (exec_router plan_entry) — no point resting when spread > 5 bp.

Net: yes, jev‑style OB‑state quoting can outsmart the book; FLIGHT already built the outsmarting (SRC‑01 + EV gate + atomic modify). The adaptation is grafting jev's clean buildState + post‑only cadence onto that deterministic learned gate — not adding an LLM to the placement path.

6.6 KiB Raw Blame History Unescape Escape