# FoxhuntQ-Δ — Belief Bus + Conformal Distributional RL for HFT Futures (v4 final design)

**Status**: DESIGN v4 (final, research-honest). Implementation pending.
**Date**: 2026-05-14
**Author session**: SP22 H6 vNext close-out → production-inference audit → multi-round literature review
**Branch (start point)**: `sp20-aux-h-fixed` @ `19bb3bc3c`

---

## Version history

- **v1** — initial brainstorm: decoupled supervised alpha + small RL execution
- **v2** — research-backed critique: added Phase 0 (purging + bar audit), softened goals to tiered, MLP baseline, meta-labeling framing, class weights
- **v3** — ambitious novel math: Hawkes + Neural SDE + conformal layered combination ("FoxhuntQ-Stochastic")
- **v4** — research-honest final: drops Neural SDE (training instability) + Hawkes-as-substrate (O(N²) MLE prohibitive), cites prior work explicitly, positions Belief Bus as the genuine novelty

---

## TL;DR (v4)

FoxhuntQ-Δ is a GPU-native trading system applying **already-published math** (distributional RL + conformal prediction + change-point adaptation) to an **underexplored domain** (imbalance-bar HFT futures with MBP-10 microstructure) through a **novel substrate** (Belief Bus — a GPU-resident publish-subscribe bus with per-slot distributional semantics + conformal coverage + causal DAG metadata).

We are not inventing the math layer. We are integrating mature components into a coherent GPU-native system, applied to a domain where the existing literature is sparse. Honest positioning: **applied research + systems engineering**, not theoretical breakthrough.

---

## What we tried and what failed (16+ SP-runs of evidence)

| Pattern | Outcome | Failure mode |
|---|---|---|
| Per-bar branching DQN with C51/IQN dueling | WR pinned at ~0.435 | Per-bar decisions on per-trade objectives |
| Aux head on shared trunk | Aux starves Q (or Q starves aux) | Shared trunk gradient competition |
| Aux head on separate trunk (K=2/K=3/K=5) | One-shot bootstrap then frozen | Label-diversity feedback loop |
| Atom-shift from outcome prediction | WR=0.458 via Hold-collapse, PF=1.08 | One-sided risk signal |
| Per-bar dense reward shaping | Sharpe-gaming without alpha | Reward-shape gaming |
| Plan-conditioning | No movement | Plan head untrained (no backward) |
| Dueling V+A combined naively | Q(Flat) attractor | V/A unidentifiable |
| TD(λ) for credit assignment | Doesn't bridge horizon gap | Trade lifecycles >> TD horizon |

**Common failure mode**: per-bar Q over 108 actions confuses signal-extraction (alpha) with execution-policy. Every fix tunes the same wrong machine harder.

---

## Goals (calibrated to literature)

Per `project_goal_wr_55_pf_2` + CFTC 2014 E-mini HFT study (median HFT WR ~55% with PF 1.2-1.4):

| Tier | WR | PF | Status |
|---|---:|---:|---|
| **Minimum viable** | ≥ 50% | ≥ 1.4 | Beats DQN baseline; deploy if reached |
| **Goal** | ≥ 53% | ≥ 1.7 | Top-half of measured HFT firms |
| **Stretch** | ≥ 55% | ≥ 2.0 | Original goal; aggressive top-quartile HFT |

Stretch is aspirational; deployment decision triggered at minimum-viable.

---

## Prior work this design builds on

Honest citation list. Components are mature; combination + domain are ours.

### Foundation papers (established, well-cited)

| # | Citation | Year | What it gives us |
|---|---|---|---|
| 1 | Bellemare, Dabney, Munos. "A Distributional Perspective on RL" (PMLR 70:449-458) | 2017 | C51 — categorical distributional Q. **Already implemented in foxhunt SP5+.** |
| 2 | Dabney et al. "Distributional RL with Quantile Regression" (AAAI) | 2018 | QR-DQN. **Already implemented.** |
| 3 | Dabney et al. "Implicit Quantile Networks" (ICML) | 2018 | IQN. **Already implemented in foxhunt SP5+.** |
| 4 | Vovk, Gammerman, Shafer. *Algorithmic Learning in a Random World* | 2005 | Conformal prediction foundation. |
| 5 | Romano, Patterson, Candès. "Conformalized Quantile Regression" (NeurIPS) | 2019 | CQR — combines quantile regression with conformal. |
| 6 | Gibbs, Candès. "Adaptive Conformal Inference Under Distribution Shift" (NeurIPS) | 2021 | ACI — online CP recalibration under shifts. |
| 7 | López de Prado. *Advances in Financial Machine Learning* | 2018 | Triple-barrier labeling, purging + embargo, imbalance bars, meta-labeling. |

### 2024-2025 papers we directly build on

| # | Citation | Venue | Why it matters |
|---|---|---|---|
| 8 | Chernozhukov et al. "Distributional Conformal Prediction" (PNAS) | 2021 | CQR applied to **daily stock returns**; coverage holds across volatility regimes. Validates conformal-on-finance. |
| 9 | Sun, Yu. "Conformal Prediction for Time-series Forecasting with Change Points" (arXiv:2509.02844 / NeurIPS 2025) | 2025 | **CPTC** — explicit change-point handling via latent state prediction; asymptotic validity without stationarity. Drop-in for our adaptive CP. |
| 10 | "Conformal Prediction Beyond the Horizon: Distribution-Free Uncertainty for Infinite-Horizon RL" (arXiv:2510.26026 / NeurIPS 2025) | 2025 | **Critical**: CP wrapping any DRL estimator with finite-sample coverage. Uses pseudo-returns + weighted subsampling. We **port this algorithm** instead of inventing. |
| 11 | Berti, Kasneci. "TLOB: A Novel Transformer Model with Dual Attention" (arXiv:2502.15757) | 2025 | TLOB transformer for LOB. Also reveals **MLPLOB** (simple MLP) often matches transformers — motivates our MLP baseline. |
| 12 | Zhu, Zhu. "AlphaQCM: Alpha Discovery in Finance with Distributional Reinforcement Learning" (ICML 2025, PMLR 267:80463-80479) | 2025 | **Different problem** (formula discovery, not execution) but introduces **QCM** (Quantiled Conditional Moment) for unbiased variance from IQN quantiles. We **adopt QCM** as our IQN uncertainty estimator. |

### Architecture papers (validate ISV / Belief Bus pattern)

| # | Citation | What it gives us |
|---|---|---|
| 13 | LMAX Disruptor design notes (Thompson et al.) | Shared-memory ring buffer pub/sub at ~600 ns. Validates pub/sub-without-broker. |
| 14 | NVIDIA CUDA Unified Memory docs | Zero-copy pub/sub between CPU and GPU at 100-500 ns. Our mapped-pinned ISV uses this. |
| 15 | Bacry, Mastromatteo, Muzy. "Hawkes Processes in Finance" (arXiv:1408.5497) | 2015 | Hawkes for LOB. **DEFERRED in v4** due to O(N²) MLE; included for completeness if Phase 6+ revisits. |
| 16 | Kidger et al. "Neural SDEs as Infinite-Dimensional GANs" (PMLR 139) | 2021 | Neural SDE done right (Wasserstein, full-path optimization). **DEFERRED in v4** due to "notoriously difficult to train". |

### Our internal foundation (already shipped)

The full SP1-SP22 series of ISV slots, adaptive controllers, GPU kernel infrastructure. See `MEMORY.md` and `docs/dqn-wire-up-audit.md` for details. The relevant items:

- **ISV signal bus** — 539 named slots, mapped-pinned, GPU-resident, ~100-500 ns latency. Genuinely ours.
- **Distributional Q (C51 + IQN)** — fully implemented; the algorithm in [10] wraps exactly this.
- **Triple-barrier outcome labels** — `trade_outcome_label_kernel.cu` implements [7]'s pattern in CUDA.
- **Imbalance bars** — Lopez de Prado [7]; bar-distribution audit in Phase 0.
- **Wiener-α adaptive smoothing**, **Pearl A bootstrap**, **per-class CE weights** — adaptive controller patterns that extend naturally to Belief Bus.
- **PER replay buffer** — for distributional Q.

---

## What's genuinely ours (the narrowed claim)

Three things hold up under rigorous review:

### 1. The Belief Bus as substrate

ISV is a 539-slot mapped-pinned GPU pub/sub for adaptive control state, but every slot is a scalar. The Belief Bus extends each slot to a **Belief**:

```
struct Belief {
    float mean;            // point estimate (current ISV value)
    float std;             // uncertainty
    float conformal_q90;   // 90% coverage radius (per-slot CP)
    uint32_t n_obs;        // observations contributing (Pearl A bootstrap state)
    uint32_t last_update;  // step counter (staleness check)
    float decay_rate;      // half-life for freshness
    uint8_t causal_parents[4]; // DAG metadata: up to 4 slots this depends on
}
```

32 bytes per Belief; a 1024-slot bus is 32 KB on the L40S. Still mapped-pinned. Still ~500 ns latency.

**Novelty**: per-slot conformal coverage + causal DAG metadata on a microsecond-latency GPU pub/sub bus is not in published literature. Components (distributional state, pub/sub, causal DAGs) are individually known; the GPU-substrate integration with financial controllers is the contribution.

### 2. Application to imbalance-bar HFT futures

Existing distributional CP + DRL papers use:
- Daily stock returns (Chernozhukov 2021)
- General RL benchmarks (arXiv:2510.26026)
- Alpha formula discovery (AlphaQCM)

We apply to:
- Imbalance bars (Lopez de Prado event-driven sampling)
- MBP-10 full 10-level depth (rare in published trading ML)
- Triple-barrier outcome labels with sparse multi-class structure
- Plan-conditioned execution (target_bars × profit_target × stop_loss × conviction × asymmetry × trail_distance)
- Single-symbol concentration (ES.FUT specialization, not multi-asset portfolio)

This is application-novel and matches our 38 GiB of MinIO data.

### 3. Adaptive controllers + conformal coverage everywhere

SP11-style adaptive controllers (signal-driven Wiener-α smoothers, no tuned constants) extended to maintain conformal coverage on every adaptive quantity in the system. Not just alpha is calibrated — every reward cap, every Adam hyperparameter, every Kelly prior has conformal coverage attached to its Belief Bus slot. Per `feedback_adaptive_not_tuned` extended to per-belief coverage guarantees.

---

## Architecture

```
                     FoxhuntQ-Δ
                     
   Imbalance bars (17.8M from fxcache) + raw MBP-10 (35 GiB MinIO)
            │
            ▼
   ┌──────────────────────────────────────────────────────┐
   │  Multi-Resolution Encoder                            │
   │  Phase 1a: MLP baseline (2-layer GELU 256-d)         │ ← cheap falsification
   │  Phase 1b: TLOB / Mamba2 / Liquid CfC                │ ← reuse ml-supervised/
   │  Output: features for distributional alpha           │
   └────────────────────┬─────────────────────────────────┘
                        │
                        ▼
   ┌──────────────────────────────────────────────────────┐
   │  Distributional Alpha (IQN — already implemented)    │
   │  Outputs: 32 quantiles of E[return | enter]          │
   │  Existing GPU kernels (SP5+)                         │
   │  QCM-derived variance (per AlphaQCM ICML 2025)       │ ← new uncertainty est
   └────────────────────┬─────────────────────────────────┘
                        │
                        ▼
   ┌──────────────────────────────────────────────────────┐
   │  CPTC Calibration Layer                              │
   │  Latent regime predictor (HMM / Random Forest)       │
   │  Online adaptive conformal per regime                │
   │  Outputs: P_calibrated + conformal_q90               │
   │  Algorithm: arXiv:2509.02844 (CPTC, NeurIPS 2025)    │
   └────────────────────┬─────────────────────────────────┘
                        │
                        ▼
   ┌──────────────────────────────────────────────────────┐
   │  Belief Bus (ISV-2)                                  │ ← novel substrate
   │   alpha_drift   = Belief{μ, σ, q90, parents}         │
   │   regime        = Belief{p_dist, n_obs, decay}       │
   │   q_magnitude   = Belief{Q_dir, drift_T}             │
   │   kelly_prior   = Belief{wins, std, decay}           │
   │   ...all current ISV slots upgraded                  │
   │  GPU pub/sub at ~500 ns; mapped-pinned coherence     │
   └────────────────────┬─────────────────────────────────┘
                        │
                        ▼
   ┌──────────────────────────────────────────────────────┐
   │  Coverage-Gated Kelly Execution                      │
   │  f* = (2·P_calibrated − 1) · max_kelly ·             │
   │       (1 − q90/q90_max) ·                            │
   │       (1 − regime.drift_T)                           │
   │  Deterministic; no RL training required for MVP      │
   └────────────────────┬─────────────────────────────────┘
                        │
                        ▼
   ┌──────────────────────────────────────────────────────┐
   │  Lifecycle Manager (unchanged from current)          │
   │  Profit/Stop/Timeout enforcement                     │
   └──────────────────────────────────────────────────────┘
                        │
   ┌────────────────────┴ (optional Phase 5+) ────────────┐
   ▼                                                       ▼
 ┌─────────────────────┐                       ┌──────────────────────┐
 │ Conformal-DRL Q     │                       │ Hawkes intensity     │
 │ (residual on Kelly) │                       │ as Belief Bus feature│
 │ Port arXiv:2510.    │                       │ (not as bar sampler) │
 │ 26026 algorithm     │                       │                      │
 └─────────────────────┘                       └──────────────────────┘
```

### Failure-mode resolution

| Current DQN failure | FoxhuntQ-Δ resolution |
|---|---|
| WR pinned at 0.435 | Alpha is supervised + calibrated; WR is a tunable threshold on calibrated probability |
| Hold-attractor | "Hold" isn't a Q action; default is "pass" (no per-bar Q reward for inaction) |
| Label-diversity collapse | Alpha trains on dense bar-level labels — full distribution always |
| PF erodes when WR rises | PF controlled by Kelly sizing weighted by uncertainty; alpha controls WR; decoupled |
| Overconfident softmax | Conformal coverage replaces softmax confidence — distribution-free guarantee |
| Adam loss-weight no-op | Each component has ONE loss; no per-loss weight tuning |
| Reward-shape gaming | Reward = realized P&L at trade close; no per-bar shaping |
| Dueling V/A unidentifiable | No Q-net needed for MVP; Kelly is closed-form |
| Plan-head untrained | No separate plan head — plan is INPUT feature to alpha |
| Label leakage (H=60 horizon) | Phase 0 implements Lopez de Prado purging + embargo |
| Imbalance-bar EWMA explosion | Phase 0 bar-distribution audit; dollar-bar fallback if needed |
| Class imbalance in triple-barrier | Phase 2 inverse-frequency class weights |

---

## Phased implementation plan

Each phase has explicit falsification gates. Compute costs estimated for L40S at our scale.

### Phase 0 — Validation harness + bar audit (~2-3 days)

**Goal**: literature-standard data hygiene.

- Implement purged walk-forward in `crates/ml-core/src/validation/`
- Embargo window calc from horizon H
- Bar-distribution audit (inter-arrival times, drift over time, EWMA equilibration check)
- Compare to dollar-bar alternative
- Output: `docs/plans/2026-05-XX-foxhuntq-phase0-report.md`

**Gate**: none (hygiene, not falsification).

### Phase 1a — MLP baseline alpha (~1-2 days)

**Goal**: cheapest test that signal exists.

- 2-layer GELU MLP (256-hidden) over fxcache features
- Binary CE loss on `aux_sign_label` (purged variant)
- Single fold, 20% holdout
- **Gate**: validation accuracy > 0.52 (vs 0.50 random baseline)

**Falsification**: if MLP pins at 0.50-0.52 even with purging, trigger Phase 1C (tick-resolution).

### Phase 1b — Sophisticated encoders (~3-5 days)

- TLOB transformer (reuse `ml-supervised/tlob/`)
- Mamba2 SSM (reuse `ml-supervised/mamba/`)
- Liquid CfC (reuse `ml-supervised/liquid/`)
- Same purged walk-forward, same binary CE
- **Gate**: best single-arch > 0.55

**Falsification**: if no arch exceeds 0.55, complex encoders aren't helping; trigger Phase 1C.

### Phase 1C — Tick-resolution (conditional, ~5-7 days)

Only if Phase 1a + 1b both falsify. Directly tests bar-resolution hypothesis from `project_bar_resolution_is_actual_architecture`.

- Raw MBP-10 → tick-level feature pipeline
- Tick-time labels (forward N-tick direction)
- MLP + TLOB baselines at tick resolution
- **Gate**: tick-res > 0.55 where bar-res was < 0.52

**Falsification**: if tick-res also fails, fundamental signal absence; FoxhuntQ-Δ does not proceed.

### Phase 2 — Multi-head alpha + IQN distributional output (~5-7 days)

**Goal**: alpha produces a full distribution (not just direction), with class-weighted multi-head training.

- Add IQN output head to Phase 1's best encoder (reuse existing IQN GPU kernels from SP5+)
- Add trade-outcome 3-class head (Profit/Stop/Timeout) with **per-batch inverse-frequency CE weights** (restoring deleted task #51's scope, per Lopez de Prado class-imbalance handling)
- Add next-bar return quantile loss (5 quantiles)
- Adopt **QCM** (Quantiled Conditional Moment) from AlphaQCM ICML 2025 for unbiased variance estimation from IQN quantiles
- Multi-fold purged walk-forward
- **Gate**: trade-outcome CE < 1.0 (vs ln 3 = 1.099 uniform) AND direction accuracy > 0.55

### Phase 3 — Belief Bus substrate (~5-7 days)

**Goal**: extend ISV → Belief Bus; migrate existing controllers.

- Define `Belief` struct + GPU kernel ABI (32-byte slots)
- `read_belief()`, `update_belief_observation()`, `belief_decay_tick()` kernels
- Migration shim: every current ISV slot auto-upgrades to a `Belief{mean=ISV.val, std=Wiener-derived, conformal_q90=0_initial}`
- Producer→consumer protocol with causal DAG validation
- FoldReset registry extended for Belief slot lifecycle
- Visualization: HEALTH_DIAG-equivalent showing per-belief uncertainty
- **Gate**: all current SP-* controllers run unchanged through Belief Bus shim; lib tests pass

### Phase 4 — CPTC calibration layer (~5-7 days)

**Goal**: change-point-aware adaptive conformal on alpha outputs.

- Latent regime predictor (start with HMM, ~5 states; can upgrade to learned later)
- Online conformal recalibration per-regime with forgetting factor
- Algorithm: arXiv:2509.02844 (Sun & Yu, CPTC, NeurIPS 2025) ported to Rust+CUDA
- Outputs flow into Belief Bus as `alpha.conformal_q90`
- **Gate**: empirical coverage on out-of-sample fold ≥ 88% at target 90% (5% slack acceptable for finite-sample)

### Phase 5 — Coverage-Gated Kelly execution (~3-5 days)

**Goal**: closed-form sizing using calibrated probability + conformal uncertainty.

- Read `alpha.mean`, `alpha.q90`, `regime.drift_T` from Belief Bus
- Compute `f* = (2P − 1) · max_kelly · (1 − q90/q90_max) · (1 − regime.drift_T)`
- Wire to existing `gpu_experience_collector` action selection (replace action argmax with Kelly fraction → quantized to {Short, Long} × {S, M, L})
- Backtest using terminal P&L reward + existing tx_cost model
- **Gate**: validation **PF ≥ 1.4 AND WR ≥ 50%** (minimum-viable tier)

### Phase 6 — Production wiring + shadow mode (~5-7 days)

- `FoxhuntQAdapter` implementing `ModelInferenceAdapter`
- Replace `services/trading_service/src/main.rs:255` registration
- Restore `trading-service.yaml` `replicas: 1`
- Shadow-mode 2 weeks
- **Gate**: shadow WR ≥ 50% over 2 weeks of live data

### Phase 7 (optional) — Conformal-DRL Q residual (~1.5-2 weeks if pursued)

**Goal**: wrap our existing IQN distributional Q with finite-sample coverage guarantees by porting Algorithm 1 from Gan, Lu, Zhang, Liu (arXiv:2510.26026, NeurIPS 2025).

**Triggered only if** Phase 5 minimum-viable hits but goal tier (WR ≥ 53% / PF ≥ 1.7) doesn't — meaning Kelly-baseline leaves performance on the table that a learned Q-residual might capture.

#### Concrete algorithm port

The 2510.26026 algorithm is a split-conformal wrapper around any distributional RL estimator. We port directly into our existing IQN infrastructure (`crates/ml/src/cuda_pipeline/gpu_iqn_head.rs`).

**Setup mapping**:

| Paper element | Foxhunt equivalent |
|---|---|
| `η̂^π(s)` (return distribution) | Existing IQN 32-quantile output |
| `v̂^π(s)` (value function) | Mean of 32 IQN quantiles |
| `D_tr` (train set) | Phases 2-5 IQN training data |
| `D_cal` (calibration set) | Held-out fold (FoxhuntQ-Δ purged walk-forward — Phase 0) |
| Replay buffer | Existing `crates/ml-dqn/src/gpu_replay_buffer.rs` (extended) |
| Transition tuple `(S_it, A_it, R_it, S_{i,t+1})` | Existing per-bar collector output |

**Algorithm steps (port-equivalent of paper Algorithm 1)**:

1. **Training**: Phases 2-5 already produce trained IQN η̂^π(s). No new training step.
2. **Value function**: compute `v̂^π(s) = mean(IQN_quantiles(s))` per bar via existing GPU reduction kernels.
3. **Density-ratio estimator**: train logistic regression `ŵ_on(s) = P(test | s) / P(cal | s)` on `(test_states, cal_states)` features.
4. **For b = 1:B replicates (parallel on GPU)**:
   - Weighted-subsample `l` calibration tuples using `ŵ_on`
   - Compute **k-step pseudo-return** (Eq. 1 of paper):
     `G̃^(k)(S_it) = Σ_{h=0..k-1} γ^h · R_{i,t+h}  +  γ^k · sample(η̂^π(S_{i,t+k}))`
   - Score: `V_it = |G̃^(k)(S_it) − v̂^π(S_it)|`
   - Quantile: `q̂_{1−αξ}` = ⌈l(1−αξ)⌉-th smallest of `{V_it}`
   - Interval: `Ĉ^(b)(S_test) = v̂^π(S_test) ± q̂_{1−αξ}`
5. **Aggregate**: `G ∈ Ĉ_final(S_test)` iff `Σ_b 1[G ∈ Ĉ^(b)] ≥ (1−ξ)·B`

**Theoretical guarantee** (Theorem 1, on-policy):
$$\Pr(G^\pi(S_{\text{test}}) \in \hat{C}_{N,\alpha}(S_{\text{test}})) \geq 1 - \alpha - \Lambda(\hat w, \hat\eta^\pi)$$
where Λ has two terms: density-ratio estimation error + Wasserstein gap between true and estimated return distribution (scaled by γ^k → exponential decay with rollout length).

#### Tunable parameters (with our defaults)

| Param | Paper range | FoxhuntQ-Δ default | Why |
|---|---:|---:|---|
| `k` (rollout steps) | 1-5 | **5-10** | γ=0.99 (ours) vs γ=0.8 (paper) — our γ^k decays slower, can afford longer rollouts |
| `B` (resample replicates) | 50 | 20-50 | GPU-parallel; 50 is safe |
| `l` (subsample size) | (implicit) | ~10K | Calibration-set fraction; tune via grid |
| `ξ` (aggregation slack) | tuned | 0.5 | Standard B-replicate aggregation |
| `α` (miscoverage) | 0.1 | **0.1** | 90% coverage target |

#### Why our setup makes the algorithm cheaper than the paper's

| Aspect | Paper experiment | Our setup |
|---|---|---|
| N (trajectories / bars) | 200-400 | 17.8M bars/fold — effectively unlimited calibration |
| T (steps) | 30 | ~1000 | Longer trajectories make k-step rollouts realistic |
| GPU parallelism for B-replicates | CPU sequential | L40S parallel — B=50 is ~free |
| Density-ratio estimation | Logistic regression (small N) | GPU-native logistic regression (large N) — needs care, see risk #2 |
| Setting | They derive both on/off-policy | **We're on-policy** in Phase 5 (Kelly evaluates the policy it runs) — simpler |

#### Implementation breakdown

| Component | Path | LOC est. |
|---|---|---:|
| Pseudo-return computation kernel | `crates/ml/src/conformal_drl/pseudo_return_kernel.cu` | ~80 CUDA |
| Density-ratio estimator (GPU-native logistic regression) | `crates/ml/src/conformal_drl/density_ratio.rs` | ~150 Rust + ~50 CUDA |
| Weighted subsampling kernel | `crates/ml/src/conformal_drl/weighted_subsample_kernel.cu` | ~120 CUDA |
| Score quantile (reuses radix sort) | `crates/ml/src/conformal_drl/nonconformity.rs` | ~60 Rust |
| B-replicate aggregation | `crates/ml/src/conformal_drl/aggregate.rs` | ~60 Rust |
| Belief Bus integration (writes conformal_q90 per slot) | `crates/ml/src/conformal_drl/belief_publisher.rs` | ~100 Rust |
| Q-residual head (small MLP on Kelly action + alpha state) | `crates/ml/src/conformal_drl/q_residual.rs` | ~200 Rust |
| Test harness (replicate paper Example 1 + Mountain Car parity) | `crates/ml/src/conformal_drl/tests/` | ~300 Rust |
| Total NEW code | | **~1100 LOC** |

#### Risks

1. **Density-ratio estimation at 17.8M-bar scale** — logistic regression with 74 features may not generalize. Mitigation: regularization (L2) + cross-validation on the LR itself, OR replace with KL-importance-estimation (Sugiyama 2008) if LR fails.

2. **k > 10 produces high-variance off-policy weights** — multiplicative product of policy ratios. Mitigation: stick to k ≤ 10 (γ^10 ≈ 0.90 is still effective decay). For off-policy counterfactual evaluation (NOT Phase 5), this is a hard limit.

3. **Coverage bound depends on Wasserstein gap** — if our IQN is poorly calibrated, coverage degrades. Phase 7 ONLY makes sense after Phase 2 produces well-trained IQN. Empirical coverage on holdout must be checked: if < 85% at α=0.1, IQN needs more training.

4. **Paper's experimental validation is small** — synthetic 2-state MDP + Mountain Car. No financial data. We'd be the first finance application. Implementation correctness via Mountain Car parity test (replicate their Figure 2 numbers) is the regression check.

#### Phase 7 gate

**Trigger condition**: Phase 5 achieves WR ≥ 50% AND PF ≥ 1.4 (minimum-viable) but falls short of goal tier (WR ≥ 53% AND PF ≥ 1.7).

**Success criterion**: Phase 7 produces calibrated 90% prediction intervals on out-of-sample folds (empirical coverage ≥ 88%) AND Q-residual improves PF by ≥ 0.2 absolute over Phase 5 Kelly-only baseline.

**Falsification**: if coverage drops below 85% across multiple folds → IQN is mis-calibrated; investigate IQN training first before continuing CP wrapping.

### Deferred indefinitely

- **Neural SDE encoders** — training instability (diffusion-collapse, "notoriously difficult to train" per Kidger 2021); revisit if Phase 1-5 hits ceiling
- **Hawkes process bar replacement** — O(N²) MLE prohibitive at HFT scale; revisit at much smaller event count if needed
- **Multi-asset portfolio** — single-symbol focus first
- **Learned in-trade exit head** — only after main path proves merit

---

## Reuse map

### Direct reuse (no modification)
```
crates/ml-supervised/src/tlob/                           ← TLOB transformer (Phase 1b)
crates/ml-supervised/src/mamba/                          ← Mamba2 SSM (Phase 1b)
crates/ml-supervised/src/liquid/                         ← Liquid CfC (Phase 1b)
crates/ml/src/training/unified_trainer.rs                ← UnifiedTrainable + GpuAdamW
crates/ml/src/cuda_pipeline/gpu_iqn_head.rs              ← IQN (Phase 2)
crates/ml/src/cuda_pipeline/gpu_attention.rs             ← Multi-head attention
crates/ml/src/cuda_pipeline/gpu_grn.rs                   ← GRN block
crates/ml/src/cuda_pipeline/trade_outcome_label_kernel.cu ← Lopez de Prado triple-barrier
crates/ml-core/src/cuda_autograd/                        ← GpuLinear, GpuAdamW, Loss
crates/ml-dqn/src/replay_buffer/                         ← PER buffer (Phase 7)
crates/ml/src/fxcache.rs                                 ← 17.8M-bar dataset
infra/k8s/argo/train-template.yaml                       ← Argo workflow
scripts/argo-train.sh                                    ← CLI dispatcher (L40S default)
```

### Lightly modified
```
crates/ml/examples/train_baseline_supervised.rs          + --data-source fxcache
                                                         + multi-head losses
                                                         + class-weighted CE
                                                         + purged walk-forward
crates/ml/src/cuda_pipeline/aux_sign_label_kernel.cu     + purged variant
```

### NEW code (small, well-scoped)
```
crates/ml-core/src/validation/                           ← Phase 0
  purged_walk_forward.rs                                 ← Lopez de Prado CPCV
  embargo.rs                                             ← Embargo from H

crates/ml/src/alpha/                                     ← Phase 1-2
  mlp_baseline.rs                                        ← Phase 1a 2-layer GELU
  multi_head_adapter.rs                                  ← Direction + Outcome + Quantile
  class_weights_kernel.cu                                ← Inverse-frequency weights
  qcm_variance_kernel.cu                                 ← AlphaQCM variance estimation

crates/ml-core/src/belief_bus/                           ← Phase 3 (THE substrate)
  mod.rs
  belief.rs                                              ← Belief struct + serdes
  bus.rs                                                 ← GPU pub/sub implementation
  causal_dag.rs                                          ← DAG metadata + validation
  reset_registry.rs                                      ← FoldReset extended
  migration.rs                                           ← ISV → Belief shim

crates/ml/src/conformal/                                 ← Phase 4
  cptc.rs                                                ← CPTC algorithm port
  regime_predictor.rs                                    ← HMM latent state
  online_calibration.rs                                  ← Per-regime quantile update

crates/ml/src/foxhuntq/                                  ← Phase 5
  kelly_execution.rs                                     ← Coverage-Gated Kelly
  adapter.rs                                             ← FoxhuntQAdapter

crates/ml/src/conformal_drl/                             ← Phase 7 (optional)
  pseudo_returns.rs                                      ← arXiv:2510.26026 port
  weighted_subsampling.rs

config/training/foxhuntq-{alpha,calibration,kelly}.toml  ← per-phase configs
docs/plans/2026-05-XX-foxhuntq-phase{0,1,2,...}.md       ← per-phase impl plans
```

### Throw away (after Phase 6 ships)
```
crates/ml/src/ensemble/adapters/dqn.rs::DqnInferenceAdapter
                                                         ← Orphan; dist_dueling untrained
crates/ml-dqn/src/dqn.rs::DQN::forward                   ← Bad routing through dist_dueling
Per-bar reward shaping components (sp11, sp12, popart, cf, micro, trail, bonus)
                                                         ← Replaced by terminal P&L
```

---

## Open questions / risks

### 1. Bar-resolution hypothesis untested under honest meters
Per `project_label_horizon_is_bottleneck.md` and `project_bar_resolution_is_actual_architecture.md`. Phase 1a (MLP + purged validation) is the direct test. If it falsifies at every tested encoder, Phase 1C (tick-resolution) is the deeper test.

### 2. CPTC requires a regime predictor
Initial: HMM-based, ~5 states (could match our K=5 regime_label output). Risk: HMM may underperform deep latent state models. Mitigation: start simple, upgrade if Phase 4 coverage falls below 88%.

### 3. Belief Bus migration risk
Every adaptive controller in foxhunt currently reads/writes ISV scalars. Migration to Belief slots requires careful shim. Risk: production controllers break during migration. Mitigation: phased — Belief Bus stays read-equivalent to ISV in Phase 3 (publishes `Belief.mean` for legacy consumers); new consumers use full Belief in Phase 4+.

### 4. PF ≥ 2.0 may not be achievable
Per CFTC HFT data: median firms hit ~55% WR with PF 1.2-1.4. Stretch goal may exceed realistic ceiling for our setup (no colocation, retail-scale costs). Mitigation: tiered success criteria — minimum-viable (50%/1.4) is the deployment trigger.

### 5. Kelly may suffice; Q optional
Phase 5 deploys Kelly-only. If WR + PF hit minimum-viable, Phase 7 may not be needed. Saves substantial complexity.

### 6. Trading service currently at replicas=0
Pre-existing latent issue (dist_dueling orphan). Phase 6 restart requires coordination + shadow mode minimum 2 weeks.

### 7. Backwards compatibility during transition
Keep `branching_q_network` + DQN trainer intact during Phases 0-6. Only delete after Phase 6 proves merit. `19bb3bc3c` is the last known-DQN state.

### 8. Conformal coverage in non-stationary settings
Even CPTC requires the latent state model to be approximately correct. If regime shifts are truly unpredictable (no signal in latent state), CP will under-cover during shifts. Mitigation: monitor empirical coverage on holdout in Phase 4; if < 85%, widen intervals or use weighted-CP fallback.

### 9. Compute cost
Phase 0-5 total: ~30-50 L40S-hours compute + ~6-8 weeks engineering. Phase 7 adds ~1-2 weeks if pursued. Within budget for a major architectural revision.

---

## Success criteria (final)

| Tier | WR | PF | Trigger |
|---|---:|---:|---|
| **Phase 5 minimum-viable** | ≥ 50% | ≥ 1.4 | Deploy via Phase 6 (shadow → live) |
| **Phase 5 goal** | ≥ 53% | ≥ 1.7 | Deploy + Phase 7 (Q residual) extension |
| **Phase 5 stretch** | ≥ 55% | ≥ 2.0 | Deploy + Phase 5+ extensions (Hawkes, Neural SDE explore) |

All measured on **purged out-of-sample folds**, **decomposed cost model** (commission + spread + slippage), **no Sharpe-inflation**.

---

## Memory references

- `project_sp22_h6_vnext_resume.md` — SP22 H6 vNext smoke verdict (this session)
- `project_foxhuntq_architectural_pivot.md` — high-level memory entry
- `pearl_k3_head_bootstrap_then_freeze.md` — label-diversity feedback loop
- `pearl_wr_pf_anticorrelation_hold_collapse.md` — degenerate Hold-attractor mode
- `pearl_trade_target_rate_freeze_indicator.md` — controller-lock indicator
- `pearl_imbalance_bar_ewma_washes_out_configured_threshold.md` — bar-distribution drift
- `project_goal_wr_55_pf_2.md` — recalibrated to tiered in v4
- `project_label_horizon_is_bottleneck.md` — alternative hypothesis (Phase 1C tests)
- `project_bar_resolution_is_actual_architecture.md` — alternative hypothesis (Phase 1C tests)
- `pearl_reward_shape_drives_quality_over_quantity.md` — deprecated; v4 uses terminal-only reward
- `pearl_audit_unboundedness_for_implicit_asymmetry.md` — asymmetric clamp pattern still applies
- `feedback_smoke_validation_before_structural_priors.md` — validate Phase 1 before merit tuning
- `feedback_kill_runs_on_anomaly_quickly.md` — falsification-gate discipline
- `feedback_no_quickfixes.md` — design over hot-patching
- `feedback_adaptive_not_tuned.md` — every Belief Bus slot is signal-driven

---

## What this doc is NOT

- **Not an implementation plan** — phase-specific impl plans follow as separate docs.
- **Not a commitment to delete DQN immediately** — Phases 0-5 run parallel; deprecate after Phase 6.
- **Not a theoretical breakthrough claim** — all math layers are published; combination is the contribution.
- **Not "another FinRL"** — FinRL is high-level Python framework; FoxhuntQ-Δ is GPU-native microsecond-latency substrate.
- **Not "we invented conformal-DRL"** — arXiv:2510.26026 published this 2025; we port the algorithm.
- **Not "we invented adaptive CP for time series"** — Sun & Yu 2025 published CPTC; we use it.
- **Not claiming SOTA on any standard benchmark** — claiming applied-research value on an underexplored domain (imbalance-bar HFT futures with MBP-10).

The honest pitch:

> *FoxhuntQ-Δ ports validated 2021-2025 ML research (distributional RL, conformal prediction, change-point CP, distributional CP for finance) to imbalance-bar HFT futures, integrated through a novel GPU-resident publish-subscribe Belief Bus substrate with per-slot distributional semantics and causal DAG metadata. The math layer is published; the substrate is ours; the application domain is underexplored. Target: WR ≥ 50% and PF ≥ 1.4 at minimum-viable, ≥ 55% / ≥ 2.0 stretch.*
