jgrusewski 9ea7692abd feat(ml-alpha): Phase 7b F5 — state-conditional action availability mask
Adds the no-op-set / direction / trail-at-cap action availability mask
specified in §3.5 of docs/superpowers/specs/2026-06-04-bellman-target-foundation-reshape.md.

## What lands

* New kernel `cuda/rl_state_action_mask.cu` (~115 LOC) modelled on
  `rl_band_mask.cu`'s lattice — Grid=(B), Block=(1,1,1), single thread
  per block, ISV-gated, reads `pos_state[b*pos_bytes+0..4]` for
  `position_lots` and the existing per-batch per-unit trail buffers
  (`unit_trail_distance`, `unit_initial_r`, `unit_active`).
* New ISV slot `RL_F5_STATE_MASK_ENABLED_INDEX = 823` (binary master
  gate; bootstrap 0.0 = OFF; preserves Phase 7a `43e7b6383`
  bit-equality). `RL_SLOTS_END` bumped 823 → 824.
* Trainer integration: `launch_rl_state_action_mask` public wrapper +
  inline call sites at the two policy-sampling paths
  (`step_with_lobsim` and `step_with_lobsim_gpu_body`), inserted BEFORE
  `rl_pi_action_kernel` so the sampler sees the masked logits. Both
  sites sit inside the prefill graph capture (device-side master gate
  preserves bit-equality across off↔on flips). `isv_constants` array
  size bumped 274 → 275.
* `build.rs` registers the new cubin.

## Mask semantics (when slot 823 > 0.5)

* `position_lots == 0` (flat) → mask {Hold=2, FlatFromLong=3,
  FlatFromShort=4, TrailTighten=7, TrailLoosen=8, HalfFlatLong=9,
  HalfFlatShort=10}. Surviving support: {ShortLarge=0, ShortSmall=1,
  LongSmall=5, LongLarge=6} — agent is FORCED to open.
* `position_lots > 0` (long) → mask all short-side actions
  {ShortLarge=0, ShortSmall=1, FlatFromShort=4, HalfFlatShort=10}.
  Same-side opens (5/6) remain available; pyramid resolution stays in
  `actions_to_market_targets.cu`.
* `position_lots < 0` (short) → symmetric.
* Any active unit at trail-cap (`trail_distance ≥ unit_initial_r *
  RL_TRAIL_MAX_INITIAL_R_RATIO * (1 − 1e-3)`) → additionally mask
  TrailLoosen (mq2pc-specific gate per spec §3.5 trail-at-cap branch).

## Composition with F2 (Q-distill hinged advantage)

F2 computes `π_target` from unmasked E_Q; F5 sets `pi_logits[masked] =
−INFINITY` so `softmax(pi_logits)` has EXACTLY zero mass on masked
actions (F5-G1 design requirement). The distill gradient
`(π_θ − π_target)` evaluates to `(0 − π_target_masked)` at masked
actions, which naturally drives the target off those actions —
gradient consistency without re-masking inside `rl_q_pi_distill_grad`.

## Action enum (verified against actions_to_market_targets.cu and
   crates/ml-alpha/src/rl/common.rs)

| id | name           | masked from flat | masked from long | masked from short |
|----|----------------|------------------|------------------|-------------------|
|  0 | ShortLarge     |                  | ✓                |                   |
|  1 | ShortSmall     |                  | ✓                |                   |
|  2 | Hold           | ✓                |                  |                   |
|  3 | FlatFromLong   | ✓                |                  | ✓                 |
|  4 | FlatFromShort  | ✓                | ✓                |                   |
|  5 | LongSmall      |                  |                  | ✓                 |
|  6 | LongLarge      |                  |                  | ✓                 |
|  7 | TrailTighten   | ✓                |                  |                   |
|  8 | TrailLoosen    | ✓                | (cap-only)       | (cap-only)        |
|  9 | HalfFlatLong   | ✓                |                  | ✓                 |
| 10 | HalfFlatShort  | ✓                | ✓                |                   |

(There are NO separate PyramidLong/PyramidShort actions in foxhunt;
pyramid logic resolves inside `actions_to_market_targets.cu` when
same-side opens fire from an existing position.)

## Surfer-principle trade-off (acknowledged per spec §3.5 + §4.1.4)

F5 destroys patience-while-waiting-for-setup by construction. F2
preserves the surfer principle mathematically (Open mass = 0 when
E_Q(Open) ≤ baseline); F5 sacrifices it for choice-set enforcement.
Bootstrap 0.0 keeps F5 OFF until F2 alone fails the Tier 1.5 / Tier 2
verdict AND the operator explicitly accepts the trend-follower
regression. Reversible at runtime via ISV re-seed.

## Verification

* `cargo build --release --example alpha_rl_train -p ml-alpha` clean.
* Determinism (band off, F5 off / band on, F5 off / F5 ON via
  temporary bootstrap=1.0): all three PASS — `determinism-check.sh
  --quick` reports byte-equal `eval_summary.json` and
  `alpha_rl_train_summary.json` plus checksum-equal diag rows.
* Invariants (band_invariants 11/11, eval_diag_emission 1/1,
  multi_head_policy_invariants 18/18, phase_5_invariants 3/3): 33/33
  PASS.

## STOP-on-surprise — F5 mechanism vs downstream gate-stack interaction

50-step smoke with F5 ON (bootstrap=1.0, then reverted) surfaced an
EXPECTED interaction documented in spec §3.5 expected-failure-mode #5:

* F5 mask itself is mechanically correct — `pi_logits[masked] = −INF`,
  softmax mass is zero, `rl_pi_action_kernel` samples only from
  {0,1,5,6} from flat.
* BUT the downstream gates that run AFTER `rl_pi_action_kernel` —
  `rl_confidence_gate` (lines 67-74 read `pos_state`, override opens
  from flat to Hold when C51 confidence is low), `rl_frd_gate`,
  `rl_session_risk_check`, `rl_min_hold_check` — re-introduce Hold
  into the executed action histogram. F5-G1 (`hold_frac_flat == 0`)
  is therefore NOT achieved by this commit alone.

The F5 kernel does what the spec asks; the gate-stack interaction is
the orthogonal wiring the spec called out as out-of-scope for F5
correctness. A follow-up plan should either suppress those gates'
Hold override when `isv[823] > 0.5 AND position_lots == 0`, OR
re-launch the F5 mask AFTER the gate stack (single extra device-side
kernel invocation). The mask kernel and ISV slot land here so the
follow-up is purely a wiring task. Per the STOP-on-unexpected-finding
discipline (feedback_investigation_first_falsification_methodology),
no further fix is applied in this dispatch.

## Files

* `crates/ml-alpha/cuda/rl_state_action_mask.cu` (new, ~115 LOC)
* `crates/ml-alpha/build.rs` (kernel registration)
* `crates/ml-alpha/src/rl/isv_slots.rs` (slot 823 + RL_SLOTS_END bump)
* `crates/ml-alpha/src/trainer/integrated.rs` (cubin include, struct
  fields, ctor load + struct init, `launch_rl_state_action_mask`
  wrapper, ISV bootstrap entry + array size bump 274→275, two inline
  call sites at `step_with_lobsim` and `step_with_lobsim_gpu_body`)

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
2026-06-05 01:00:01 +02:00

Foxhunt

Production HFT trading system in Rust.

Architecture

The workspace contains 32 crates organized as follows:

Core Libraries (16)

Crate Purpose
trading_engine Order processing, FIX 4.4, IB TWS, SIMD, RDTSC timing
risk VaR, Kelly, circuit breakers, kill switches, compliance
risk-data Risk data types and shared structures
trading-data Trading data types
ml DQN Rainbow, PPO, TFT, Mamba2, ensemble inference
ml-data ML data types and feature definitions
data Market data ingestion and storage
backtesting Replay engine, strategy tester
adaptive-strategy Ensemble execution, microstructure analysis
common Shared types, resilience, error handling
storage S3 and local model storage
model_loader Model serialization and loading
market-data Market data feed handlers
database PostgreSQL access layer (SQLx)
config Configuration management
tli CLI commands and tooling

Services (8)

Service Purpose
backtesting_service gRPC backtesting service
broker_gateway_service FIX routing, broker connectivity
trading_service Core trading operations
ml_training_service Model training orchestration
data_acquisition_service Market data acquisition
trading_agent_service Autonomous trading agents
api_gateway gRPC API gateway with auth
web-gateway Axum REST + WebSocket gateway

Frontend

web-dashboard/ -- React 19 + TypeScript + Vite + TradingView charts.

Building

# Check compilation (no PostgreSQL required)
SQLX_OFFLINE=true cargo check --workspace

# Run tests for a specific crate
SQLX_OFFLINE=true cargo test -p <crate> --lib

# Clippy
SQLX_OFFLINE=true cargo clippy --workspace

ML Models

Four production model architectures on Candle v0.9.1 with CUDA:

  • DQN Rainbow -- Deep Q-Network with prioritized replay, dueling heads, noisy nets
  • PPO -- Proximal Policy Optimization with GAE and LSTM policies
  • TFT -- Temporal Fusion Transformer for multi-horizon forecasting
  • Mamba2 -- State space model for sequence prediction

Each model has a standalone trainer and a UnifiedTrainable adapter for the hyperopt pipeline.

Infrastructure

  • Git: Gitea at git.fxhnt.ai (Tailscale-only), Scaleway DEV1-S
  • Observability: OpenTelemetry OTLP (env OTEL_EXPORTER_OTLP_ENDPOINT)
  • Database: PostgreSQL with SQLx offline mode for CI

License

Proprietary. All rights reserved.

Description
No description provided
Readme 849 MiB
Languages
Rust 88.2%
Cuda 7.7%
Python 1.3%
Shell 1.1%
PLpgSQL 0.8%
Other 0.8%