uv(parity): DATA WIRING CENSUS — 24 live / 4 defaulted / 9 missing; holes concentrate at tpsl_ticker:319-348 + dead hook 10 + env pins

prod/docs/uv_cert/exit_crawl/DATA_WIRING_CENSUS_20260713.md

@@ -0,0 +1,186 @@
+# DATA WIRING CENSUS — UV flight-4 vs BLUE (2026-07-13)
+
+**Question (HJ):** "how the hell are not ALL data sources where they belong" — exhaustive
+census of every data source BLUE's decision + exit surfaces consume, and whether UV wires it.
+
+**Method:** READ-ONLY crawl. BLUE anchors from `/mnt/dolphinng5_predict/prod/nautilus_event_trader.py`
+(`_process_scan` 4051+, feeders 905–1400, ADVSL block 4835–4919, V7 hook 1241–1338),
+`adaptive_exit/advanced_sl.py`, `nautilus_dolphin/.../alpha_exit_v7_engine.py`,
+`esf_alpha_orchestrator.py`. UV anchors from the LOCAL tree
+`/root/uv-wt/refactor/prod/clean_arch/violet/uv/` (runner, blue_prime, hooks, tpsl_ticker,
+modulation ports, exec/e_feed). Cross-checked against `BIT_PARITY_UNROLL_VS_UV_20260713.md`
+and `UV_EXIT_CRAWL.md`. Note: `mcp__argos__*` was not reachable in this session; filesystem
+tools were used per CLAUDE.md fallback.
+
+**Verdicts:**
+- **WIRED-LIVE** — real feed reaches the UV consumer.
+- **WIRED-DEFAULT** — consumer runs on a silently defaulted / neutral value (DANGEROUS; default listed).
+- **MISSING** — UV consumer exists but the input is never supplied.
+- **N-A** — BLUE-only scope, or superseded by an equivalent-or-better UV mechanism.
+
+All UV paths below are relative to `/root/uv-wt/refactor/prod/clean_arch/violet/uv/`;
+all BLUE paths relative to `/mnt/dolphinng5_predict/`.
+
+---
+
+## 1. Decision surface (scan loop → 11 feeders → step_bar)
+
+| # | Input | Source of truth | BLUE consumer | UV wiring | Verdict |
+|---|---|---|---|---|---|
+| D1 | NG7 scan (scan_number, assets, asset_prices) | HZ `DOLPHIN_FEATURES["latest_eigen_scan"]` | `prod/nautilus_event_trader.py:4051+` (`_process_scan`) | `blue_prime/runner.py:217,340–345` (same key + BLUE's own `normalize_ng7_scan`) | **WIRED-LIVE** |
+| D2 | vel_div (non-finite clamp) | scan field | `:4112–4115` | `blue_prime/runner.py:59` + `blue_prime/context.py:121` | **WIRED-LIVE** |
+| D3 | w50 / w750 velocities | scan fields | `:4117–4121` | `runner.py:61–62` + `context.py:124–125` → `harness.step` (`blue_prime/engine.py:79–86`) | **WIRED-LIVE** |
+| D4 | instability_50 | scan field | `:4209` (eigen_scans journal) + market_state via scan_payload `:4171` | `context.py:126,161` + `runner.py:446` (scan journal) + hook 09 scan_payload | **WIRED-LIVE** |
+| D5 | prices + stablecoin removal | scan fields, `_STABLECOIN_SYMBOLS` (`:24`) | `:4102–4106` | BOTH paths filter: `runner.py:44–63` (engine path — T10R4 fix) + `context.py:38–41,118` (ctx path) | **WIRED-LIVE** |
+| D6 | vol_ok (BTC 50-window stddev vs p60) | computed from scan BTC price | `:4021–4036` (`_compute_vol_ok`), used `:4110` | hook `hooks/01_vol_ok.py` (same window/threshold, env `DOLPHIN_VOL_P60_THRESHOLD` dflt 0.00026414); runner runs it FIRST + rebuilds ctx (`runner.py:354–361`) | **WIRED-LIVE** |
+| D7 | posture (APEX/TURTLE/HIBERNATE) | HZ `DOLPHIN_SAFETY["latest"|"posture"]` | `:2582,2797` (`_read_posture`, 10s cache), sync block `:4128–4161` | `blue_prime/live_inputs.py:68–88` (same keys, same 10s cache, fail-soft APEX) → `ctx.posture` → hook `hooks/03_posture_sync.py` | **WIRED-LIVE** |
+| D8 | ESoF payload | HZ `DOLPHIN_FEATURES["esof_latest"|"esof_advisor_latest"]` | `:761` (`_read_esof_payload`), gate `:4164` | `live_inputs.py:91–109` (parses via BLUE's own `esof_size_gate.parse_esof_payload`) → hook `hooks/04_esof_size_gate.py` (sets engine advisory score; engine computes `_esof_size_mult` itself, `esf_alpha_orchestrator.py:856–858`) | **WIRED-LIVE** |
+| D9 | ExF snapshot (funding/dvol/fear_greed/taker) — decision surface | HZ `DOLPHIN_FEATURES["exf_latest"]` | listener `:2826` → `self._last_exf` | `live_inputs.py:112–124` → `ctx.exf_snapshot` → hooks 06 + 09 | **WIRED-LIVE** (decision side only — see X4/X8 for the exit-side holes) |
+| D10 | OB engine construction (live OB provider) | HZ OB maps via `HZOBProvider(dolphin@127.0.0.1:5701)` | trader init + `self.ob_eng` | `blue_prime/deps.py:127–154` (`build_prime_deps`, fail-soft; raw first-scan universe enforced `runner.py:222–229`, hard-fails if absent) | **WIRED-LIVE** |
+| D11 | OBF step_live (per-bar OB clock) | OB engine internal | `:4124–4125` | hook `hooks/02_ob_step_live.py` (same instance, engine `_global_bar_idx` clock) | **WIRED-LIVE** |
+| D12 | OBF mid-price injection for open-position asset | HZ `DOLPHIN_FEATURES["obf_universe_latest"]` (live WS bid/ask, ≤3s fresh) | `:928–951` (`_inject_obf_midprice`), applied `:4187–4188` **before** `step_bar :4193` | hook `hooks/10_obf_midprice.py` exists BUT (a) it reads `ctx.extras["obf_universe_latest"]` (`10_obf_midprice.py:15`) which **no producer ever sets** (grep: only reader exists); (b) even if set, the hook's output prices live only in `HookEffect.mutations` — `runner.py:367–370` steps the engine with pre-hook `inp["prices"]` | **MISSING** (double-dead) |
+| D13 | SC threshold advisor (shadow) | `SCThresholdAdvisor.load(strategy="blue", shadow_db="dolphin")` | `:691–698`, evaluate `:953–994` (sc, vel_div, exf, esof, trade_history, current_mult) | `deps.py:156–165` + hook `hooks/06_sc_threshold_advisor.py:41–54` — passes vel_div, `ctx.exf_snapshot`, `ctx.esof_payload`, live `engine._esof_size_mult` via `hooks/advisor_context.py` | **WIRED-LIVE** (shadow) |
+| D14 | SC gauge advisor (shadow) | `SCGaugeAdvisor.load(...)` + `build_obf_snapshot_from_engine` | `:702–709`, evaluate `:1340–1373` | `deps.py:167–176` + hook `hooks/07_sc_gauge_advisor.py` (OBF snapshot from same ob_engine) | **WIRED-LIVE** (shadow) |
+| D15 | Runtime direction (base −1) | env/config on trader | `:580–597` | `runner.py:353` hardcodes `trade_direction=-1` → hook `hooks/08_runtime_direction.py` (exact branch parity) | **WIRED-LIVE** |
+| D16 | EFSM state — pending LONG-overlay slots / active | BLUE: in-process `PostWinExecutionFSM` (`:486,4222–4234,4656–4674`), never published | `_resolve_runtime_direction :580–589` | `blue_prime/efsm_state.py` (`EfsmMirror`): instantiates the SAME BLUE class, replays **`dolphin.trade_events`** (`:5,115,167`) + context gate from `dolphin.maras_fingerprint` (`:254`) + `dolphin.obf_universe` BTC window (`:286`); refreshed each scan `runner.py:180` | **WIRED-LIVE** — with caveat: slots derive from **BLUE's** closed-trade stream, not UV's own fills (see H7) |
+| D17 | market_state_runtime feed (scan_payload, prices, vel/v50/v750, vol_ok, posture, exf, esof) | in-process `MarketStateRuntime` | ctor `:454`, update `:4169–4183` | `runner.py:154–163,230` (`_attach_market_state`) + hook `hooks/09_market_state.py:41–53` — full arg parity | **WIRED-LIVE** as a *producer* — but its outputs are consumed by NOBODY in UV (see X4) |
+| D18 | Hibernate protect — bucket TP+SL arming | `adaptive_exit/models/bucket_assignments.pkl` + `_BUCKET_SL_PCT` | load `:722–732`; arm `:2424–2452` (`stop_pct_override` per bucket); trigger `:4144–4159` | hook `hooks/03_posture_sync.py` sets `engine._hibernate_protect_active=True` FLAG ONLY — never loads buckets (grep: zero bucket refs in uv/), never arms `stop_pct_override` | **MISSING** (bucket SL arm); flag path itself wired |
+| D19 | `hibernate_protect_active` per-scan state | trader attr (trade_id) | `:477,4146–4159` | `context.py:151` pins `extras["hibernate_protect_active"]: False` every scan; runner never overrides | **WIRED-DEFAULT** (`False` always) |
+| D20 | Catastrophic floor config | BLUE env `DOLPHIN_CATASTROPHIC_FLOOR_PCT` / overlay floor / max-loss | `:2456–2548` applied `:4192` | hook `hooks/11_catastrophic_floor.py` wired; BUT `runner.py` passes no `floor_cfg`, so `context.py:133–143` hard defaults 0.0120 / 0.0050 / $500 — UV does NOT read the BLUE env knobs | **WIRED-DEFAULT** (0.0120 / 0.0050 / 500.0 — matches BLUE defaults today, silently diverges if operator retunes BLUE via env) |
+| D21 | TP threshold sync (soft curve from capital+notional) | tp_curve (`prod/clean_arch/tp_curve.py`) + capital + open-position notional | `:805–827` (`_tp_curve_context`), `:905–926` (`_sync_tp_threshold` → `eng.set_live_tp_pct`) | hook `hooks/05_tp_threshold.py` — same compute, BUT `capital = engine.capital` = the embedded engine's **paper** capital (init 25000, sim PnL), not venue E | **WIRED-LIVE** with divergence (see H8) |
+| D22 | ACB / proxy-boost / EsoF gate / bet sizer internals | engine-internal (`create_d_liq_engine`) | inside `step_bar` | same REAL engine, same `ENGINE_KWARGS` (AST-extracted, `blue_prime/engine.py:32–43`) | **WIRED-LIVE** |
+| D23 | EFSM overlay entry tagging + observe-closed-trade lifecycle | live FSM on trader | `:4222–4253` (tag), `:4656–4674` (observe) | mirror replays the same class over `dolphin.trade_events`; UV's own promotion path does not call `tag_next_entry` on its own entries | **N-A** for parity shadow / caveat for solo flight (H7) |
+
+## 2. Exit surface (TP / SL / MAX_HOLD / ADVSL / V7)
+
+| # | Input | Source of truth | BLUE consumer | UV wiring | Verdict |
+|---|---|---|---|---|---|
+| X1 | OBF exit ingress: cascade_count, regime_signal, imbalance_ma5, withdrawal_velocity, base 250 | ob_engine `get_signal`/`get_macro` at evaluation_bar | `AlphaExitManager.evaluate` (kernel) + trader | `max_hold_modulation.py:133–202` (`build_engine_ingress_provider`) — strict `_live_mode`/`_live_bar_idx` sync check (166–171); refuses stale cache → journaled `NO_INGRESS_FALLBACK` (tpsl_ticker.py:467–492) | **WIRED-LIVE** (fail-explicit, journaled) |
+| X2 | MAX_HOLD modulation (250 → ×0.5/×0.4/×1.5/×0.40 branches) | ingress X1 | `AlphaExitManager.evaluate` branch order | `max_hold_modulation.py:78–116` (`blue_max_hold_yield`, doctrinal order) driven per scan `tpsl_ticker.py:272–297` | **WIRED-LIVE** |
+| X3 | TP curve + OBF TP modulation + TP_FLOOR | base anchor `_tp_base_pct` (`:455`), capital, notional, ingress X1 | `:805–827,905–926` + kernel exit manager (×1.40 cascade etc.) | `tp_exit_modulation.py:70–137` (`blue_tp_yield`); base anchor from engine (`runner.py:322–329`); capital from **E-anchored venue provider** (`runner.py:262–265`, `tpsl_ticker.py:384–388`); trigger order TP_FLOOR→TP→SL in `brain_tpsl.py:334–383` | **WIRED-LIVE** |
+| X4 | ADVSL `market_state` (choppiness, dd_pressure, trend, compression, mean-reversion, confidence) | `market_state_runtime.latest_state` | `:4837,4857` passes it into `advanced_sl.evaluate` (`adaptive_exit/advanced_sl.py:592`) | consumer param EXISTS (`advanced_sl_port.py:190`) but caller `tpsl_ticker.py:343–348` **never passes it** → `{}` → `choppy=dd=trend=compression=0` (`advanced_sl_port.py:83–88`) | **MISSING** — kills ADVSL (see H1) |
+| X5 | ADVSL `exf_snapshot` | `self._last_exf` | `:4859` | param EXISTS (`advanced_sl_port.py:191`) but never passed at `tpsl_ticker.py:343–348` → defaults funding=0, dvol=0, fear=50, taker=0.5 → `exf_stress` frozen at 0.20 (`advanced_sl_port.py:89–99`) | **MISSING** — co-kills ADVSL (H1) |
+| X6 | ADVSL `market_bundle` | `market_state_runtime.latest_bundle_dict` (+MARAS merge `:824–825`) | `:4838,4858` | hardcoded `market_bundle={}` at `advanced_sl_port.py:211` | **MISSING** |
+| X7 | ADVSL `ae_shadow` (AdaptiveExitEngine p_continuation) | `_ae_ref.evaluate(...)` per position | `:4825–4833,4855` | UV port has no `ae_shadow` param at all; pure runtime falls back to `v7.p_continuation` else 0.5 (`advanced_sl_port.py:104–112`) | **MISSING** (neutral 0.5 stand-in) |
+| X8 | ADVSL `meta_performance` (EFSM `exit_policy_meta` over MARAS ctx) | HZ `DOLPHIN_FEATURES["maras_latest"]` (`:527–535`) → `:4840–4844,4860` | absent; UV pure runtime substitutes constant `0.12*0.5` in score (`advanced_sl_port.py:126`) | **MISSING** (declared out-of-scope in port docstring — still a BLUE input UV drops) |
+| X9 | ADVSL recent_prices tape | BLUE `_record_bounce_prices` (`:4108`) scan-price path | `:4824,4854` | `tpsl_ticker.py:299–308,343–346` — mark-price poll tape (~1 s, ≥ scan resolution), 32-deep, entry-seeded | **WIRED-LIVE** (finer than BLUE) |
+| X10 | V7 forecast — ExF context (`ctx.set_exf(funding,dvol,fear_greed,taker)`) | `self._last_exf` | `:1269–1288` | `exit_v7_wrapper.py` accepts `exf` (param present, `_apply_exf`) but `tpsl_ticker.py:337–340` never passes it → V7 runs with zero EXF state | **MISSING** |
+| X11 | V7 forecast — ob_imbalance | `ob_eng.get_signal(asset, eval_bar).imbalance_ma5` RAW | `:1292–1312`; engine treats it as raw direction (`alpha_exit_v7_engine.py:493 ob_direction = ob_imbalance`) | ingress X1 delivers the same field, BUT `tpsl_ticker.py:319–321` **sign-flips it for SHORT** before `evaluate` — BLUE does not | **WIRED-LIVE with SIGN DEVIATION** (H2) |
+| X12 | V7 decision → ADVSL `v7_decision` (exit_pressure, p_cont, mae/mfe_risk) | `self._v7_decisions[tid]` (`:1315,4839,4856`) | | `tpsl_ticker.py:322–347` (`VioletExitV7Adapter.last_raw_decision`) | **WIRED-LIVE** (but degraded by X10/X11 upstream) |
+| X13 | Exit price feed | BLUE: scan prices + OBF mid-price override | `_manage_position` via step_bar | `tpsl_ticker.py:65–79` BingX mark-price REST (~1 s, full precision, off-thread pool 137–141, 620–640); scan-lane falls back to entry price until first poll (`:242–247`, counted `_scan_price_fallbacks`) | **WIRED-LIVE** (superior cadence/precision) |
+| X14 | bars_held / hold clock | engine bar clock | kernel exit manager | `tpsl_ticker.on_bar` once per processed scan (`runner.py:374–382`) + kernel-slot rehydration `_sync_from_kernel` (`tpsl_ticker.py:525–611`) | **WIRED-LIVE** |
+| X15 | SL: catastrophic floor + withdrawal widen | 1.2% floor, regime_signal==1 → 10% | kernel `AlphaExitManager.evaluate` | `sl_exit_modulation.py:47–71` (`blue_sl_yield`: min(configured,0.012), widen 0.10) resolved per tick `brain_tpsl.py:355–366` | **WIRED-LIVE** (modulation) — configured input is X16 |
+| X16 | Configured TP/SL fractions at arm | UV env `UV_TP_PCT` / `UV_SL_PCT` (mandatory when `UV_TPSL_ENABLE=1`, `tpsl_ticker.py:699–704`) | N-A (BLUE: ENGINE_KWARGS fixed_tp 0.0020, stop 1.00+floor) | pinned **nowhere** in the repo — only tests set them; a mis-set env silently reshapes every exit (SL parity holds only if `UV_SL_PCT ≥ 0.012`) | **WIRED-DEFAULT/UNPINNED** (H4 — known hole, verified) |
+| X17 | Capital for TP curve (exit lane) | venue account truth | BLUE ledger capital | `make_e_capital_provider(zinc_plane)` fed by E-feed (`runner.py:262–277`, `tpsl_ticker.py:384–388`); fail-soft to None → curve at capital 0 | **WIRED-LIVE** |
+| X18 | Notional (exit lane) | position qty × entry | pos.notional | `tpsl_ticker.py:399` (`pos.quantity * pos.entry_price`) | **WIRED-LIVE** |
+| X19 | Overlay-ADVSL exit gate (LONG overlay positions) | `_overlay_advsl_should_exit` cfg `:472–476,2523–2551` | `:4866–4878` | absent in UV; hook 08 CAN resolve LONG overlay entries, but no overlay-specific ADVSL/V7 pressure gate exists on the exit side | **MISSING** (conditional on UV ever taking overlay LONGs) |
+| X20 | ADVSL live-exit actuation channel | HZ `blue_runtime_commands` queue `:4880–4907` | | UV uses in-process steel-lane dispatch (`brain_tpsl` + `TpSlHandler`, M6 worker `tpsl_ticker.py:113–122`) | **N-A** (superseded, by design) |
+
+## 3. Account / venue truth
+
+| # | Input | Source of truth | BLUE consumer | UV wiring | Verdict |
+|---|---|---|---|---|---|
+| A1 | Account/E truth (balance, fills) | BLUE: capital anchor + Σ deltas (checkpoint/HZ pnl/position_state, `:1424–1760`) | trader capital ledger | UV: `exec/e_feed.py` (CEX-010: ASEx-owned BingX stream + REST gap-backfill, sole publisher into zinc plane) `runner.py:270–277`; armed promotion **fail-closes** on staleness | **WIRED-LIVE** (stronger law than BLUE) |
+| A2 | E→K kernel mirror | applied EEvents | N-A | `exec/e_k_bridge.py` (one-way E→K through single kernel owner) `runner.py:271–274` | **WIRED-LIVE** |
+| A3 | Position truth for exits | BLUE engine position | | kernel Zinc slots (`runner.py:261`, `tpsl_ticker._sync_from_kernel`) — qty, fill price, terminal state, restart rehydration | **WIRED-LIVE** |
+| A4 | Venue readiness (no order before readiness) | N-A in BLUE | | `exec/venue_readiness.py` probes (venue_connect, e_feed_ready, capital_fresh, zinc healthy) `runner.py:283–306`, fail-DARK | **WIRED-LIVE** (UV-only safety addition) |
+| A5 | HZ write protection | BLUE writes HZ freely | | `no_write_guard` + `hz_readonly.wrap_hz_client` (`runner.py:30–39`) | **N-A** (UV doctrine: never write BLUE reference state) |
+| A6 | `live_tp_threshold` HZ observability key | HZ `DOLPHIN_FEATURES["live_tp_threshold"]` (docstring `:909`) | BLUE computes locally `:905–926` (does not actually read the key) | UV computes locally (hook 05) + journals TP ingress rows to `dolphin_uv` | **N-A** (neither system consumes it as an input) |
+
+---
+
+## VERDICT COUNTS
+
+- **WIRED-LIVE: 24** (D1–D11, D13–D17, D22, X1–X3, X9, X12–X15, X17, X18, A1–A4 — counting grouped rows once)
+- **WIRED-DEFAULT: 4** — D19 (hibernate flag pinned False), D20 (floor cfg hard-coded 0.0120/0.0050/500), X16 (UV_TP_PCT/UV_SL_PCT unpinned env), X7-fallback constant p_cont=0.5
+- **MISSING: 9** — X4 (ADVSL market_state), X5 (ADVSL exf), X6 (ADVSL market_bundle), X7 (ae_shadow), X8 (meta_performance/MARAS), X10 (V7 ExF), X19 (overlay ADVSL gate), D12 (OBF mid-price, double-dead), D18 (hibernate bucket SL)
+- **N-A: 4** — X20, A5, A6, D23
+- **Deviations flagged: 2** — X11 (V7 ob_imbalance sign flip), D21/H8 (two-capital divergence)
+
+---
+
+## HOLES — ordered by money impact
+
+### H1 — ADVSL is mathematically DEAD (market_state + exf never passed) — CRITICAL
+`tpsl_ticker.py:343–348` calls `AdvancedSlPort.evaluate` without `market_state=`/`exf_snapshot=`
+although both params exist (`advanced_sl_port.py:190–191`). With `state={}` and `exf={}` the
+pure runtime computes a **deterministic** stress = 0.34·0 + 0.22·0 + 0.18·(1−0) + 0.12·(1−0)
++ 0.14·0.20 = **0.328**, and `gate_stress` requires ≥ **0.52** (`advanced_sl_port.py:100–101,132`).
+`would_exit = all(gates)` → the ASL_PRESSURE_CONT_STRESS full-retract **can never fire**, on any
+tape, ever. UV's only non-mechanical loss-cutting exit is a no-op while its counters
+(`advsl_evaluations`) tick up green. BLUE passes both live
+(`nautilus_event_trader.py:4837,4857–4859`). Fix: thread `market_state_runtime.latest_state`
+(already produced each scan by hook 09 — currently produced-and-dropped, D17) and
+`ctx.exf_snapshot` from the runner into the ticker's ADVSL call.
+
+### H2 — V7 forecast runs blind + sign-flipped — HIGH
+(a) BLUE seeds every V7 context with live ExF (`nautilus_event_trader.py:1269–1288`); UV never
+passes `exf` to `VioletExitV7Adapter.evaluate` (`tpsl_ticker.py:337–340`) though the wrapper
+supports it. (b) BLUE feeds V7 the RAW `imbalance_ma5` (`:1292–1312`;
+`alpha_exit_v7_engine.py:493` uses it as-is); UV flips the sign for SHORT positions first
+(`tpsl_ticker.py:319–321`) — every SHORT (i.e. nearly every UV trade) hands V7 an inverted OB
+direction. V7's `exit_pressure` feeds ADVSL's pressure gate and the journals, so even after H1
+is fixed, ADVSL fires on wrong-signed microstructure.
+
+### H3 — OBF mid-price injection is double-dead — HIGH (for embedded-engine exits)
+Hook 10 exists but (a) nothing ever puts `obf_universe_latest` into `ctx.extras`
+(`hooks/10_obf_midprice.py:15` is the only reference in uv/), and (b) even if it did, the
+hook's output prices never reach `step_bar` — `runner.py:367–370` uses pre-hook `inp["prices"]`,
+whereas BLUE reassigns `prices_dict` before stepping (`:4187–4196`). Coarse ~4-decimal scan
+prices for a 0.20% TP is the exact failure class behind BLUE's TP-masking incident. Mitigation:
+UV's REAL positions exit through the mark-price ticker (X13), so exposure is confined to
+embedded-engine decision parity (exit timing the engine believes in vs what UV actuates) — but
+that is the parity being certified.
+
+### H4 — UV_TP_PCT / UV_SL_PCT unpinned in any launcher — HIGH (verified known hole)
+`maybe_build_ticker` hard-requires both when arming (`tpsl_ticker.py:699–704`) and they are set
+**nowhere** in the repo outside tests (grep across .sh/.py/.conf/.md; supervisor conf has no UV
+entry). SL parity with BLUE (1.2% catastrophic floor dominant) holds only if `UV_SL_PCT ≥ 0.012`;
+a fat-fingered export silently retunes every exit with no journal of provenance. Pin both in the
+canonical launcher/env file with the doctrine values.
+
+### H5 — Hibernate protect arms a flag, not a stop — MEDIUM
+BLUE's HIBERNATE-with-open-position path arms a per-bucket `stop_pct_override` from
+`bucket_assignments.pkl` + `_BUCKET_SL_PCT` (`:722–732, 2424–2452`). UV hook 03 only sets
+`engine._hibernate_protect_active=True`; no bucket file is ever loaded in uv/ and no override is
+armed. Additionally `context.py:151` pins `hibernate_protect_active=False` every scan (D19), so
+the hook re-enters the arm branch each scan. Rare posture, but it is precisely the
+capital-protection path for the worst regime.
+
+### H6 — Catastrophic floor config frozen at code defaults — MEDIUM
+UV never reads `DOLPHIN_CATASTROPHIC_FLOOR_PCT` / overlay env knobs; `runner.py` passes no
+`floor_cfg`, so `context.py:135–143` hard-codes 0.0120/0.0050/500.0. Identical to BLUE **today**,
+silently divergent the day the operator retunes BLUE via env.
+
+### H7 — EFSM overlay slots track BLUE's trades, not UV's — MEDIUM (semantics)
+`EfsmMirror` replays `dolphin.trade_events` (`efsm_state.py:5,115,167`) — BLUE's closed-trade
+stream. Correct for shadowing BLUE; for UV as an independent live trader it means UV's own wins
+never arm UV's post-win LONG overlay, and BLUE's wins arm overlay LONGs in UV's book. Related:
+X19 — if such an overlay LONG is taken, UV has no overlay-ADVSL exit gate
+(BLUE `:2523–2551,4866–4878`).
+
+### H8 — Two capitals: hook 05 TP threshold uses paper capital — LOW/MEDIUM
+`hooks/05_tp_threshold.py` computes `live_tp_pct` from `engine.capital` (embedded engine's
+simulated ledger, init 25000), while the actuating ticker TP uses venue-E capital (X17). BLUE
+uses one ledger for both. As venue E and paper capital drift apart, the engine's internal exit
+view and UV's actuated TP diverge.
+
+### H9 — ADVSL context degradations behind H1 — LOW (masked until H1 fixed)
+`ae_shadow` absent (p_cont neutral 0.5, X7), `market_bundle` hardcoded `{}`
+(`advanced_sl_port.py:211`, X6), MARAS `meta_performance` absent with constant 0.5 stand-ins in
+the score (`advanced_sl_port.py:117,126`, X8). Note MARAS IS already queryable in UV
+(`efsm_state.py:239–279` reads `dolphin.maras_fingerprint`) — the plumbing exists one module away.
+
+---
+
+## What is demonstrably RIGHT (so the fix stays scoped)
+
+The entire decision surface is genuinely live: real NG7 scans, real prices with dual stablecoin
+filtering, real posture/ESoF/ExF from the same HZ keys with BLUE's own parsers, the REAL
+D_LIQ_GOLD engine with AST-pinned ENGINE_KWARGS, a live HZOBProvider OB engine stepped on BLUE's
+clock, both SC advisors with full BLUE argument sets, market-state runtime fed with full parity,
+EFSM mirrored with the genuine BLUE class, and an exit lane whose OBF ingress refuses stale
+snapshots instead of inventing neutral ones. The holes are concentrated in ONE call site
+(`tpsl_ticker.py:319–348` — ADVSL/V7 context) plus one dead hook (10) and one unpinned env pair.
+
+*Census by Fable (claude), 2026-07-13. Read-only; no source files modified.*