Upload 22 files

.github/workflows/ci.yml

@@ -0,0 +1,31 @@
+name: Build & Test
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Install dependencies
+      run: sudo apt-get update && sudo apt-get install -y cmake g++
+
+    - name: Configure CMake
+      run: cmake -B build -DCMAKE_BUILD_TYPE=Release
+
+    - name: Build all targets
+      run: cmake --build build -j$(nproc)
+
+    - name: Run unit tests
+      run: |
+        cd build
+        ctest --output-on-failure
+
+    - name: Run benchmark
+      run: ./build/hft_bench

BUG_REPORT.md

@@ -0,0 +1,511 @@
+# Complete Bug Report — HFT Exchange Simulator
+
+**Total Bugs Found: 17**  
+**Files Modified: 8**  
+**Severity: 4 Critical, 9 Medium, 4 Low**
+
+---
+
+## BUG #1 — Windows Pipe Crash (CRITICAL)
+
+**File:** `app.py` (line ~72)  
+**What was the bug:**  
+The old code used `select.select()` to read the C++ engine's stdout with a timeout. On Linux, `select.select()` works with pipe file descriptors. But on Windows, `select.select()` ONLY works with sockets — NOT with pipes. When the Python server tried to read the engine response, Windows threw an `OSError` and the entire server crashed immediately on every single API call.
+
+**What the old code looked like:**
+```python
+ready, _, _ = select.select([self.proc.stdout], [], [], ENGINE_TIMEOUT)
+if ready:
+    response = self.proc.stdout.readline().strip()
+```
+
+**How I fixed it:**  
+Replaced `select.select()` with a cross-platform thread-based approach. I spawn a short-lived daemon thread that calls `readline()`. The main thread waits for that thread with a timeout using `thread.join(timeout=ENGINE_TIMEOUT)`. If the thread is still alive after the timeout, we kill the engine and restart it.
+
+**What the fixed code looks like:**
+```python
+response_container = []
+def _read():
+    resp = self.proc.stdout.readline()
+    response_container.append(resp)
+
+reader = threading.Thread(target=_read, daemon=True)
+reader.start()
+reader.join(timeout=ENGINE_TIMEOUT)
+
+if reader.is_alive():
+    self.proc.kill()
+    self.proc = None
+    self._start()
+    raise HTTPException(504, "Engine timeout — restarted")
+```
+
+**Why this matters:** Without this fix, the entire application was 100% non-functional on Windows. Every API request would crash.
+
+---
+
+## BUG #2 — Server Crashes If Binary Is Missing (CRITICAL)
+
+**File:** `app.py` (line ~34)  
+**What was the bug:**  
+The `EngineProcess` was created at module-level (`engine = EngineProcess()`). Inside `__init__`, it called `_start()` which tried to open the C++ binary via `subprocess.Popen()`. If the binary file didn't exist (because you haven't built the C++ code yet), `Popen` would throw an exception and the entire FastAPI server would fail to start — you couldn't even see an error page.
+
+**How I fixed it:**  
+1. In `_start()`, added a check: if the binary file doesn't exist, set `self.proc = None` and return gracefully instead of crashing.
+2. Changed the module-level `engine = EngineProcess()` to `engine = None` (lazy initialization). The engine is only created when the first API request comes in via `_get_engine()`.
+
+**What the fixed code looks like:**
+```python
+engine: Optional[EngineProcess] = None
+
+def _get_engine() -> EngineProcess:
+    global engine
+    if engine is None:
+        engine = EngineProcess()
+    return engine
+```
+
+**Why this matters:** Developers can now start the Python server, see the API docs, and get a clear "binary not found" error message instead of an opaque crash.
+
+---
+
+## BUG #3 — Missing .exe Suffix on Windows (CRITICAL)
+
+**File:** `app.py` (line ~21)  
+**What was the bug:**  
+The binary path was hardcoded as `"hft_engine"`. On Windows, compiled C++ executables have a `.exe` extension. So the server was looking for a file called `hft_engine` which doesn't exist on Windows — it should be looking for `hft_engine.exe`.
+
+**What the old code looked like:**
+```python
+ENGINE_PATH = Path(__file__).parent / "build" / "hft_engine"
+```
+
+**How I fixed it:**
+```python
+_engine_name = "hft_engine.exe" if sys.platform == "win32" else "hft_engine"
+ENGINE_PATH = Path(__file__).parent / "build" / _engine_name
+```
+
+**Why this matters:** Without this, even if the binary was built successfully on Windows, the server would never find it.
+
+---
+
+## BUG #4 — Sell-Side Iterator Invalidation (CRITICAL)
+
+**File:** `src/core/order_book.cpp` (line ~113)  
+**What was the bug:**  
+This is the most dangerous C++ bug in the entire project. When a SELL order comes in, the matching engine needs to match it against the best BID (highest price). The old code used a `for` loop iterating backwards through `bids_` (a `std::map`):
+
+```cpp
+for (auto it = bids_.end(); it != bids_.begin() && incoming.remaining() > 0; ) {
+    --it;
+    // ... matching logic ...
+    if (resting->is_done()) {
+        level.orders.pop_front();
+        orders_.erase(resting->id);
+        if (level.empty()) {
+            it = bids_.erase(it);  // ← erases the current element
+            break;                  // ← breaks inner while loop
+        }
+    }
+}
+// Back to outer for loop → does --it on the ERASED iterator → UNDEFINED BEHAVIOR
+```
+
+The problem: After `bids_.erase(it)`, the iterator `it` is set to the next element. Then `break` exits the inner `while` loop. Then the outer `for` loop does `--it` on this already-advanced iterator. But worse — if we erased the first element, `--it` could go before `begin()`, which is undefined behavior. This could cause random crashes, corrupted order books, or silent wrong fills under heavy load.
+
+**How I fixed it:**  
+Rewrote the entire sell-side loop to use a `while` loop that re-fetches `std::prev(bids_.end())` on each iteration. This way, after erasing a level, we simply go back to the top of the `while` loop and grab the new best bid. No iterator can be invalidated.
+
+```cpp
+while (!bids_.empty() && incoming.remaining() > 0) {
+    auto it = std::prev(bids_.end());  // always get fresh best bid
+    auto& [px, level] = *it;
+    
+    if (incoming.type == OrderType::LIMIT || incoming.type == OrderType::IOC) {
+        if (px < incoming.price) break;
+    }
+    
+    while (!level.orders.empty() && incoming.remaining() > 0) {
+        // ... matching logic (unchanged) ...
+    }
+    
+    if (level.empty()) {
+        bids_.erase(it);  // safe — we won't use 'it' again
+    } else {
+        break;
+    }
+}
+```
+
+**Why this matters:** This is the kind of bug that works fine in testing with small order books but causes random crashes in production under heavy load. A quant firm would lose real money.
+
+---
+
+## BUG #5 — to_price() Rounds Wrong for Negative Numbers
+
+**File:** `src/core/types.hpp` (line ~17)  
+**What was the bug:**  
+The `to_price()` function converts a `double` (like 185.5050) to an `int64_t` (like 1855050) by multiplying by 10000 and adding 0.5:
+
+```cpp
+inline Price to_price(double d) { return static_cast<Price>(d * PRICE_SCALE + 0.5); }
+```
+
+This `+0.5` trick works for positive numbers (it rounds 1.6 → 2, 1.4 → 1). But for negative numbers, it's WRONG:
+- `-1.5 * 10000 + 0.5 = -14999.5` → truncated to `-14999`
+- Correct answer should be `-15000`
+
+This matters because PnL calculations can produce negative intermediate values.
+
+**How I fixed it:**
+```cpp
+inline Price to_price(double d) { return static_cast<Price>(std::llround(d * PRICE_SCALE)); }
+```
+
+`std::llround()` correctly rounds both positive and negative numbers (rounds away from zero).
+
+**Why this matters:** Wrong rounding = wrong prices = wrong PnL = wrong risk calculations. Off-by-one tick errors compound over thousands of trades.
+
+---
+
+## BUG #6 — spread() Returns Garbage for Empty or Crossed Books
+
+**File:** `src/core/types.hpp` (line ~86)  
+**What was the bug:**  
+The `spread()` function calculated spread without checking if bids/asks existed:
+
+```cpp
+double spread() const {
+    return from_price(best_ask() - best_bid());
+}
+```
+
+If `bids` is empty, `best_bid()` returns 0. If `asks` is empty, `best_ask()` returns 0. So `spread()` would return `from_price(0 - 0) = 0` which is accidentally correct for empty books, BUT if you have a crossed book (best_bid > best_ask, which can happen during fast markets), you'd get a negative spread which makes no sense.
+
+**How I fixed it:**
+```cpp
+double spread() const {
+    if (bids.empty() || asks.empty()) return 0.0;
+    Price s = best_ask() - best_bid();
+    return s > 0 ? from_price(s) : 0.0;
+}
+```
+
+**Why this matters:** Strategies use spread to decide whether to quote. A negative spread could cause strategies to place inverted orders.
+
+---
+
+## BUG #7 — on_tick() Lock Placed After the Real Work
+
+**File:** `src/core/simulator.cpp` (line ~78)  
+**What was the bug:**  
+The `on_tick()` function was supposed to update market prices and record the latency. But the lock was placed AFTER the `update_market_price()` call:
+
+```cpp
+void ExchangeSimulator::on_tick(const MarketDataTick& tick) {
+    int64_t t0 = now_ns();
+    risk_.update_market_price(tick.symbol, from_price(tick.last_price));  // ← NO LOCK
+    std::lock_guard<std::mutex> lock(mtx_);  // ← lock acquired AFTER the work
+    tick_lat_.record(now_ns() - t0);  // ← latency includes lock wait time
+}
+```
+
+Two problems:
+1. `update_market_price()` runs without any protection from the simulator's mutex, so if another thread calls `submit_order()` at the same time, you have a data race on the position's unrealized PnL.
+2. The latency recorded includes the time spent waiting for the lock, which makes the metric useless — it measures contention, not processing speed.
+
+**How I fixed it:**
+```cpp
+void ExchangeSimulator::on_tick(const MarketDataTick& tick) {
+    int64_t t0 = now_ns();
+    std::lock_guard<std::mutex> lock(mtx_);  // ← lock FIRST
+    risk_.update_market_price(tick.symbol, from_price(tick.last_price));
+    tick_lat_.record(now_ns() - t0);
+}
+```
+
+**Why this matters:** Data races cause undefined behavior — corrupted PnL numbers, positions that don't add up, and intermittent crashes that are nearly impossible to reproduce.
+
+---
+
+## BUG #8 — symbols() Missing Lock (Data Race)
+
+**File:** `src/core/simulator.cpp` (line ~92)  
+**What was the bug:**  
+The `symbols()` function iterates over the `books_` map to return a list of symbol names. But it didn't acquire the mutex:
+
+```cpp
+std::vector<std::string> ExchangeSimulator::symbols() const {
+    std::vector<std::string> s;
+    for (auto& [k, _] : books_) s.push_back(k);  // ← iterating without lock
+    return s;
+}
+```
+
+If another thread calls `add_symbol()` at the same time (which DOES hold the lock and modifies `books_`), you get a data race. On `std::unordered_map`, concurrent read + write is undefined behavior — it can crash, return garbage, or corrupt the map's internal hash table.
+
+**How I fixed it:**
+```cpp
+std::vector<std::string> ExchangeSimulator::symbols() const {
+    std::lock_guard<std::mutex> lock(mtx_);  // ← added lock
+    std::vector<std::string> s;
+    for (auto& [k, _] : books_) s.push_back(k);
+    return s;
+}
+```
+
+**Why this matters:** Same as above — data races are undefined behavior in C++.
+
+---
+
+## BUG #9 — Rate Limiter Counts Rejected Orders (DoS Vulnerability)
+
+**File:** `src/risk/risk_manager.cpp` (line ~22)  
+**What was the bug:**  
+The old code recorded the order timestamp at the TOP of `check_order()`, BEFORE any validation:
+
+```cpp
+RiskResult RiskManager::check_order(const Order& order, double current_price) {
+    std::lock_guard<std::mutex> lock(mtx_);
+    ++stats_checked_;
+    order_timestamps_ns_.push_back(now_ns());  // ← counted even if rejected
+    // ... then check qty, price, position, etc.
+}
+```
+
+This means: if someone sends 2000 orders with `qty = -1` (which gets rejected immediately), all 2000 are counted toward the rate limit. Now the rate limit is exhausted, and VALID orders from a legitimate strategy also get rejected for the next second.
+
+This is a denial-of-service attack vector — a rogue client can disable all trading by spamming invalid orders.
+
+**How I fixed it:**  
+Moved the timestamp recording to AFTER all validation checks pass:
+
+```cpp
+RiskResult RiskManager::check_order(const Order& order, double current_price) {
+    std::lock_guard<std::mutex> lock(mtx_);
+    ++stats_checked_;
+
+    // All validation checks first...
+    if (order.qty <= 0) return REJECT;
+    if (order.price <= 0) return REJECT;
+    // ... position, notional, rate checks ...
+
+    // Only count approved orders toward rate limit
+    order_timestamps_ns_.push_back(now_ns());
+    return {true, "OK"};
+}
+```
+
+Also changed the rate check from `>` to `>=` (off-by-one: the old code allowed `max + 1` orders per second).
+
+**Why this matters:** In a real exchange, a rate limiter that counts rejected orders is a security vulnerability. Any client could freeze trading for everyone.
+
+---
+
+## BUG #10 — JSON Injection in Error Response (Command Name)
+
+**File:** `src/engine_cli.cpp` (line ~285)  
+**What was the bug:**  
+When an unknown command was received, the error message included the raw command name without JSON escaping:
+
+```cpp
+return "{\"error\":\"unknown command: " + cmd + "\"}";
+```
+
+If someone sends a command like `test"injected":"value`, the output becomes:
+```json
+{"error":"unknown command: test"injected":"value"}
+```
+
+This is malformed JSON. The Python side does `json.loads()` on this response, which would throw an exception, causing a 500 error instead of a clean error message.
+
+**How I fixed it:**
+```cpp
+return "{\"error\":" + J::str("unknown command: " + cmd) + "}";
+```
+
+`J::str()` properly escapes quotes and backslashes inside the string.
+
+**Why this matters:** Malformed JSON breaks the entire Python-C++ communication protocol. Any unusual input could crash the API.
+
+---
+
+## BUG #11 — JSON Injection in Exception Message
+
+**File:** `src/engine_cli.cpp` (line ~307)  
+**What was the bug:**  
+Same problem as Bug #10, but in the exception handler:
+
+```cpp
+catch (const std::exception& e) {
+    std::cout << "{\"error\":\"" << e.what() << "\"}\n";
+}
+```
+
+If `e.what()` contains a quote character (which many standard library exceptions do), the JSON output is malformed.
+
+**How I fixed it:**
+```cpp
+catch (const std::exception& e) {
+    std::cout << "{\"error\":" << J::str(e.what()) << "}\n";
+}
+```
+
+**Why this matters:** Same as Bug #10 — any exception with a quote in the message would break JSON parsing.
+
+---
+
+## BUG #12 — Out-of-Bounds Read in jget() (engine_cli.cpp)
+
+**File:** `src/engine_cli.cpp` (line ~22-23)  
+**What was the bug:**  
+The `jget()` JSON parser skips whitespace after the colon:
+
+```cpp
+while (pos < body.size() && (body[pos] == ' ' || body[pos] == '\t')) ++pos;
+if (body[pos] == '"') {  // ← if pos == body.size(), this is OUT OF BOUNDS
+```
+
+After the `while` loop, `pos` could be equal to `body.size()`. Accessing `body[pos]` when `pos == body.size()` reads past the end of the string. In C++, this is undefined behavior — it could read garbage memory, crash, or appear to work.
+
+**How I fixed it:**
+```cpp
+while (pos < body.size() && (body[pos] == ' ' || body[pos] == '\t')) ++pos;
+if (pos >= body.size()) return "";  // ← added bounds check
+if (body[pos] == '"') {
+```
+
+**Why this matters:** Out-of-bounds reads are undefined behavior. They can be exploited for information disclosure or cause crashes.
+
+---
+
+## BUG #13 — Out-of-Bounds Read in json_get() (main.cpp)
+
+**File:** `src/main.cpp` (line ~56-57)  
+**What was the bug:**  
+Exact same bug as Bug #12, but in the `json_get()` function in `main.cpp` (the HTTP server version). It's a copy-pasted function with the same flaw.
+
+**How I fixed it:**  
+Same fix — added `if (pos >= body.size()) return "";` after the whitespace skip loop.
+
+**Why this matters:** Same as Bug #12.
+
+---
+
+## BUG #14 — Feed Index Race Condition
+
+**File:** `src/main.cpp` (line ~240-241)  
+**What was the bug:**  
+The feed stepping code used an atomic counter but had a race in the reset logic:
+
+```cpp
+size_t idx = g_feed_idx.fetch_add(1);
+if (idx >= g_tick_feed.size()) { g_feed_idx = 0; idx = 0; }
+```
+
+The problem: Two threads can both see `idx >= size` at the same time. Both reset `g_feed_idx = 0`. Both use `idx = 0`. Now two requests replay the same tick. Also, `g_feed_idx = 0` is a non-atomic store on an atomic variable — technically a data race.
+
+**How I fixed it:**
+```cpp
+size_t idx = g_feed_idx.fetch_add(1) % g_tick_feed.size();
+```
+
+Using modulo (`%`) on the atomically-fetched value gives correct wraparound without any reset. Lock-free, race-free, one line.
+
+**Why this matters:** In an HFT context, replaying the same tick twice or skipping ticks means your backtest results are wrong.
+
+---
+
+## BUG #15 — Dead Code / No-Op Expression
+
+**File:** `app.py`  
+**What was the bug:**  
+There was a line that looked like it was trying to do something but was actually a no-op expression that Python evaluated and threw away:
+
+```python
+self.proc.stdout._sock if hasattr(self.proc.stdout, '_sock') else None
+```
+
+This evaluates to either a socket object or `None`, but the result is never assigned to anything or used. It does nothing.
+
+**How I fixed it:** Removed the dead code entirely.
+
+**Why this matters:** Dead code confuses future developers and suggests the original author didn't understand what they were writing.
+
+---
+
+## BUG #16 — depth Parameter Not Forwarded
+
+**File:** `app.py` (line ~191)  
+**What was the bug:**  
+The `/api/book/{symbol}` endpoint accepted a `depth` query parameter, but never actually sent it to the C++ engine:
+
+```python
+@app.get("/api/book/{symbol}")
+def book(symbol: str, depth: int = 10):
+    return _get_engine().send("book", {"symbol": symbol})  # ← depth is ignored!
+```
+
+So no matter what depth the user requested, they always got the default 10 levels.
+
+**How I fixed it:**
+```python
+return _get_engine().send("book", {"symbol": symbol, "depth": depth})
+```
+
+**Why this matters:** Silent parameter ignoring is a bug that erodes API trust. Users think they're controlling the depth but they're not.
+
+---
+
+## BUG #17 — Dangling Declaration (Linker Bomb)
+
+**File:** `src/core/simulator.hpp` (line ~104)  
+**What was the bug:**  
+The `Backtester` class declared a method `replay_journal(const std::string& path)` in the header, but the implementation (`.cpp` file) never defined it:
+
+```cpp
+class Backtester {
+public:
+    // ...
+    BacktestResult replay_journal(const std::string& path);  // ← declared but never defined
+};
+```
+
+Right now, nothing calls this function, so there's no linker error. But if anyone ever tries to call `bt.replay_journal("file.journal")`, they'll get a cryptic linker error: `undefined reference to Backtester::replay_journal`. This is a maintenance trap.
+
+**How I fixed it:** Removed the declaration entirely.
+
+**Why this matters:** Dangling declarations are tech debt that confuses future developers and causes linker errors when someone tries to use the function.
+
+---
+
+## BONUS FIXES (Cleanup)
+
+- **Removed unused imports** in `app.py`: `asyncio`, `StaticFiles`, `JSONResponse`, `time` — none were used anywhere in the file.
+- **Added `self.proc = None`** before restart in error paths — ensures the old dead process handle doesn't leak.
+
+---
+
+## Summary by File
+
+| File | Bugs Fixed | Bug Numbers |
+|------|-----------|-------------|
+| `app.py` | 7 | #1, #2, #3, #15, #16, +cleanup |
+| `src/core/types.hpp` | 2 | #5, #6 |
+| `src/core/order_book.cpp` | 1 | #4 |
+| `src/core/simulator.cpp` | 2 | #7, #8 |
+| `src/core/simulator.hpp` | 1 | #17 |
+| `src/risk/risk_manager.cpp` | 1 | #9 |
+| `src/engine_cli.cpp` | 3 | #10, #11, #12 |
+| `src/main.cpp` | 2 | #13, #14 |
+
+---
+
+## Summary by Severity
+
+| Severity | Count | Bug Numbers |
+|----------|-------|-------------|
+| 🔴 CRITICAL (crash/UB) | 4 | #1, #2, #3, #4 |
+| 🟡 MEDIUM (wrong behavior) | 9 | #5, #6, #7, #8, #9, #10, #11, #12, #13, #14 |
+| 🟢 LOW (cleanup/maintenance) | 4 | #15, #16, #17, +imports |

CMakeLists.txt

@@ -0,0 +1,65 @@
+cmake_minimum_required(VERSION 3.16)
+project(hft_simulator CXX)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+set(CMAKE_CXX_FLAGS_RELEASE "-O3 -march=native -DNDEBUG")
+if(NOT CMAKE_BUILD_TYPE)
+  set(CMAKE_BUILD_TYPE Release)
+endif()
+
+include_directories(
+  ${CMAKE_SOURCE_DIR}/include
+  ${CMAKE_SOURCE_DIR}/src
+)
+
+set(CORE_SOURCES
+  src/core/order_book.cpp
+  src/core/simulator.cpp
+  src/risk/risk_manager.cpp
+  src/journal/journal.cpp
+)
+
+# ── Production targets ────────────────────────────────────────────────────────
+
+add_executable(hft_server ${CORE_SOURCES} src/main.cpp)
+target_compile_options(hft_server PRIVATE -Wall -Wextra -pthread)
+target_link_libraries(hft_server PRIVATE pthread)
+
+add_executable(hft_engine ${CORE_SOURCES} src/engine_cli.cpp)
+target_compile_options(hft_engine PRIVATE -Wall -Wextra -pthread)
+target_link_libraries(hft_engine PRIVATE pthread)
+
+install(TARGETS hft_engine DESTINATION bin)
+
+# ── Test targets ──────────────────────────────────────────────────────────────
+
+add_executable(hft_test_orderbook
+  ${CORE_SOURCES}
+  tests/test_order_book.cpp
+)
+target_compile_options(hft_test_orderbook PRIVATE -Wall -Wextra -pthread)
+target_link_libraries(hft_test_orderbook PRIVATE pthread)
+
+add_executable(hft_test_risk
+  ${CORE_SOURCES}
+  tests/test_risk_manager.cpp
+)
+target_compile_options(hft_test_risk PRIVATE -Wall -Wextra -pthread)
+target_link_libraries(hft_test_risk PRIVATE pthread)
+
+# ── Benchmark target ──────────────────────────────────────────────────────────
+
+add_executable(hft_bench
+  ${CORE_SOURCES}
+  benchmark/bench_matching_engine.cpp
+)
+target_compile_options(hft_bench PRIVATE -Wall -Wextra -pthread -O3)
+target_link_libraries(hft_bench PRIVATE pthread)
+
+# ── CTest integration ────────────────────────────────────────────────────────
+
+enable_testing()
+add_test(NAME OrderBookTests COMMAND hft_test_orderbook)
+add_test(NAME RiskManagerTests COMMAND hft_test_risk)

Dockerfile

@@ -0,0 +1,37 @@
+FROM ubuntu:22.04
+
+ENV DEBIAN_FRONTEND=noninteractive
+
+# Install dependencies
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    cmake \
+    g++ \
+    python3 \
+    python3-pip \
+    wget \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install Python packages
+RUN pip3 install fastapi uvicorn
+
+WORKDIR /app
+
+# Copy all files
+COPY . .
+
+# Download httplib.h
+RUN wget -q https://raw.githubusercontent.com/yhirose/cpp-httplib/master/httplib.h \
+    -O src/httplib.h
+
+# Build C++ engine
+RUN mkdir -p build && cd build && \
+    cmake .. -DCMAKE_BUILD_TYPE=Release && \
+    make -j$(nproc) hft_engine
+
+# Expose port
+EXPOSE 7860
+
+# Run FastAPI server
+CMD ["python3", "app.py"]

app.py

@@ -0,0 +1,256 @@
+"""
+HFT Exchange Simulator — FastAPI server
+Wraps the C++ hft_engine binary via persistent subprocess.
+"""
+import json
+import os
+import subprocess
+import sys
+import threading
+from pathlib import Path
+from typing import Optional
+
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse
+from pydantic import BaseModel
+
+# BUG-FIX #1: Detect platform and pick the correct binary name.
+# On Windows the compiled binary has a .exe extension.
+_engine_name = "hft_engine.exe" if sys.platform == "win32" else "hft_engine"
+ENGINE_PATH = Path(__file__).parent / "build" / _engine_name
+ENGINE_TIMEOUT = 10.0
+
+
+class EngineProcess:
+    """Manages a persistent child process that speaks line-delimited JSON."""
+
+    def __init__(self):
+        self.proc: Optional[subprocess.Popen] = None
+        self.lock = threading.Lock()
+        self._start()
+
+    # ------------------------------------------------------------------
+    def _start(self):
+        if not ENGINE_PATH.exists():
+            # BUG-FIX #2: Do not crash the whole server if the binary is
+            # missing — let individual requests report the problem instead.
+            self.proc = None
+            return
+        self.proc = subprocess.Popen(
+            [str(ENGINE_PATH)],
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.DEVNULL,
+            text=True,
+            bufsize=1,
+        )
+
+    # ------------------------------------------------------------------
+    def send(self, cmd: str, payload: dict = None) -> dict:
+        if payload is None:
+            payload = {}
+        line = f"{cmd} {json.dumps(payload)}\n"
+
+        with self.lock:
+            # BUG-FIX #3: If the engine binary was never found, report it
+            # clearly instead of an opaque NoneType crash.
+            if self.proc is None or self.proc.poll() is not None:
+                self._start()
+                if self.proc is None:
+                    raise HTTPException(
+                        503,
+                        f"Engine binary not found at {ENGINE_PATH}. "
+                        "Build the C++ engine first.",
+                    )
+
+            try:
+                self.proc.stdin.write(line)
+                self.proc.stdin.flush()
+
+                # BUG-FIX #4 (THE CRASH BUG):
+                # The old code used `select.select()` which ONLY works with
+                # sockets on Windows — it raises OSError on pipe file
+                # descriptors.  Replaced with a cross-platform thread-based
+                # readline with timeout.
+                response_container: list = []
+                error_container: list = []
+
+                def _read():
+                    try:
+                        resp = self.proc.stdout.readline()
+                        response_container.append(resp)
+                    except Exception as exc:
+                        error_container.append(exc)
+
+                reader = threading.Thread(target=_read, daemon=True)
+                reader.start()
+                reader.join(timeout=ENGINE_TIMEOUT)
+
+                if reader.is_alive():
+                    # Timed out — kill and restart the engine
+                    self.proc.kill()
+                    self.proc = None
+                    self._start()
+                    raise HTTPException(504, "Engine timeout — restarted")
+
+                if error_container:
+                    raise error_container[0]
+
+                response = (
+                    response_container[0].strip() if response_container else ""
+                )
+                if not response:
+                    raise HTTPException(500, "Engine returned empty response")
+
+                return json.loads(response)
+
+            except HTTPException:
+                raise
+            except Exception as e:
+                try:
+                    self.proc.kill()
+                except Exception:
+                    pass
+                self.proc = None
+                self._start()
+                raise HTTPException(500, f"Engine error: {e}")
+
+
+# BUG-FIX #5: Lazy-initialise so the import doesn't blow up when running
+# under test-harnesses or when the binary hasn't been built yet.
+engine: Optional[EngineProcess] = None
+
+
+def _get_engine() -> EngineProcess:
+    global engine
+    if engine is None:
+        engine = EngineProcess()
+    return engine
+
+
+app = FastAPI(title="HFT Exchange Simulator", version="1.0.0")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+# ── Pydantic models ──────────────────────────────────────────────────────────
+
+class OrderRequest(BaseModel):
+    symbol: str = "AAPL"
+    side: str = "BUY"
+    type: str = "LIMIT"
+    price: float = 0.0
+    qty: int = 100
+    client_id: str = ""
+    market_price: float = 0.0
+
+
+class CancelRequest(BaseModel):
+    symbol: str
+    id: int
+
+
+class FeedStepRequest(BaseModel):
+    n: int = 10
+
+
+class BacktestRequest(BaseModel):
+    strategy: str = "MarketMaking"
+    symbol: str = "AAPL"
+    ticks: int = 5000
+    start_price: float = 185.0
+
+
+class RiskLimitsRequest(BaseModel):
+    max_order_qty: int = 10000
+    max_position: int = 500000
+    max_notional_usd: float = 50_000_000.0
+    max_orders_per_sec: int = 2000
+
+
+# ── API routes ────────────────────────────────────────────────────────────────
+
+@app.get("/api/status")
+def status():
+    return _get_engine().send("status")
+
+
+@app.get("/api/symbols")
+def symbols():
+    return _get_engine().send("symbols")
+
+
+@app.get("/api/book/{symbol}")
+def book(symbol: str, depth: int = 10):
+    # BUG-FIX #6: The `depth` query-param was accepted but never forwarded
+    # to the engine.  Now included in the payload.
+    return _get_engine().send("book", {"symbol": symbol, "depth": depth})
+
+
+@app.get("/api/positions")
+def positions():
+    return _get_engine().send("positions")
+
+
+@app.get("/api/trades")
+def trades():
+    return _get_engine().send("trades")
+
+
+@app.get("/api/orders")
+def orders():
+    return _get_engine().send("orders")
+
+
+@app.post("/api/order")
+def submit_order(req: OrderRequest):
+    return _get_engine().send("order", req.model_dump())
+
+
+@app.delete("/api/order")
+def cancel_order(req: CancelRequest):
+    return _get_engine().send("cancel", req.model_dump())
+
+
+@app.post("/api/feed/step")
+def feed_step(req: FeedStepRequest):
+    return _get_engine().send("feed_step", {"n": req.n})
+
+
+@app.post("/api/backtest")
+def backtest(req: BacktestRequest):
+    return _get_engine().send("backtest", req.model_dump())
+
+
+@app.get("/api/risk/limits")
+def get_limits():
+    return _get_engine().send("get_limits")
+
+
+@app.post("/api/risk/limits")
+def set_limits(req: RiskLimitsRequest):
+    return _get_engine().send("risk_limits", req.model_dump())
+
+
+@app.post("/api/reset")
+def reset():
+    return _get_engine().send("reset")
+
+
+@app.get("/")
+def serve_index():
+    return FileResponse(str(Path(__file__).parent / "index.html"))
+
+
+# ── Entry point ───────────────────────────────────────────────────────────────
+
+if __name__ == "__main__":
+    import uvicorn
+    port = int(os.environ.get("PORT", 7860))
+    uvicorn.run(app, host="0.0.0.0", port=port, log_level="info")

benchmark/bench_matching_engine.cpp

@@ -0,0 +1,303 @@
+// benchmark/bench_matching_engine.cpp
+// Performance benchmark — measures throughput and latency under load
+// Build: cmake --build build --target hft_bench && ./build/hft_bench
+
+#include "core/order_book.hpp"
+#include "core/simulator.hpp"
+#include "core/types.hpp"
+#include "journal/journal.hpp"
+#include <iostream>
+#include <vector>
+#include <chrono>
+#include <random>
+#include <algorithm>
+#include <iomanip>
+#include <cmath>
+#include <numeric>
+
+using namespace hft;
+using Clock = std::chrono::high_resolution_clock;
+
+struct BenchResult {
+    std::string name;
+    int64_t     ops;
+    double      total_us;
+    double      ops_per_sec;
+    double      p50_ns;
+    double      p99_ns;
+    double      p999_ns;
+    double      avg_ns;
+};
+
+static BenchResult run_bench(const std::string& name, int64_t ops,
+                              std::vector<int64_t>& latencies) {
+    std::sort(latencies.begin(), latencies.end());
+    double total_ns = 0;
+    for (auto l : latencies) total_ns += l;
+
+    BenchResult r;
+    r.name        = name;
+    r.ops         = ops;
+    r.total_us    = total_ns / 1000.0;
+    r.ops_per_sec = ops / (total_ns / 1e9);
+    r.avg_ns      = total_ns / ops;
+    r.p50_ns      = latencies[latencies.size() * 50 / 100];
+    r.p99_ns      = latencies[latencies.size() * 99 / 100];
+    r.p999_ns     = latencies[latencies.size() * 999 / 1000];
+    return r;
+}
+
+static void print_result(const BenchResult& r) {
+    std::cout << std::left << std::setw(35) << r.name
+              << std::right
+              << "  ops: " << std::setw(8) << r.ops
+              << "  throughput: " << std::setw(10) << std::fixed << std::setprecision(0) << r.ops_per_sec << " ops/s"
+              << "  avg: " << std::setw(8) << std::setprecision(1) << r.avg_ns << " ns"
+              << "  p50: " << std::setw(8) << r.p50_ns << " ns"
+              << "  p99: " << std::setw(8) << r.p99_ns << " ns"
+              << "  p999: " << std::setw(8) << r.p999_ns << " ns"
+              << "\n";
+}
+
+// ─── Benchmark 1: Order Insert (no match) ───────────────────────────────────
+
+static BenchResult bench_insert_no_match(int n) {
+    OrderBook book("BENCH");
+    std::mt19937 rng(42);
+    std::uniform_int_distribution<int> price_dist(1000, 2000);  // spread out
+    std::uniform_int_distribution<int> qty_dist(100, 1000);
+    std::vector<int64_t> latencies;
+    latencies.reserve(n);
+
+    for (int i = 0; i < n; ++i) {
+        Order o;
+        o.id     = i + 1;
+        o.symbol = "BENCH";
+        o.side   = (i % 2 == 0) ? Side::BUY : Side::SELL;
+        o.type   = OrderType::LIMIT;
+        // Spread prices so no matching occurs (buys low, sells high)
+        o.price  = (o.side == Side::BUY) ? to_price(100.0 + price_dist(rng) * 0.01)
+                                          : to_price(200.0 + price_dist(rng) * 0.01);
+        o.qty    = qty_dist(rng);
+
+        auto t0 = Clock::now();
+        book.add_order(o);
+        auto t1 = Clock::now();
+        latencies.push_back(std::chrono::duration_cast<std::chrono::nanoseconds>(t1 - t0).count());
+    }
+
+    return run_bench("Insert (no match)", n, latencies);
+}
+
+// ─── Benchmark 2: Order Match (aggressive orders) ───────────────────────────
+
+static BenchResult bench_match(int n) {
+    OrderBook book("BENCH");
+    std::mt19937 rng(123);
+    std::uniform_int_distribution<int> qty_dist(50, 200);
+    std::vector<int64_t> latencies;
+    latencies.reserve(n);
+
+    // Pre-populate the book with resting orders
+    for (int i = 0; i < n; ++i) {
+        Order o;
+        o.id     = i + 1;
+        o.symbol = "BENCH";
+        o.side   = Side::SELL;
+        o.type   = OrderType::LIMIT;
+        o.price  = to_price(100.0 + (i % 50) * 0.01);  // 50 price levels
+        o.qty    = qty_dist(rng);
+        book.add_order(o);
+    }
+
+    // Now send aggressive buy orders that match
+    for (int i = 0; i < n; ++i) {
+        Order o;
+        o.id     = n + i + 1;
+        o.symbol = "BENCH";
+        o.side   = Side::BUY;
+        o.type   = OrderType::MARKET;
+        o.price  = 0;
+        o.qty    = 1;  // small qty to match single order partially
+
+        auto t0 = Clock::now();
+        book.add_order(o);
+        auto t1 = Clock::now();
+        latencies.push_back(std::chrono::duration_cast<std::chrono::nanoseconds>(t1 - t0).count());
+    }
+
+    return run_bench("Match (market order)", n, latencies);
+}
+
+// ─── Benchmark 3: Cancel Order ──────────────────────────────────────────────
+
+static BenchResult bench_cancel(int n) {
+    OrderBook book("BENCH");
+    std::mt19937 rng(456);
+    std::uniform_int_distribution<int> price_dist(1, 1000);
+    std::vector<int64_t> latencies;
+    latencies.reserve(n);
+
+    // Insert orders
+    for (int i = 0; i < n; ++i) {
+        Order o;
+        o.id     = i + 1;
+        o.symbol = "BENCH";
+        o.side   = Side::BUY;
+        o.type   = OrderType::LIMIT;
+        o.price  = to_price(100.0 + price_dist(rng) * 0.01);
+        o.qty    = 100;
+        book.add_order(o);
+    }
+
+    // Cancel in random order
+    std::vector<int> ids(n);
+    std::iota(ids.begin(), ids.end(), 1);
+    std::shuffle(ids.begin(), ids.end(), rng);
+
+    for (int id : ids) {
+        auto t0 = Clock::now();
+        book.cancel_order(id);
+        auto t1 = Clock::now();
+        latencies.push_back(std::chrono::duration_cast<std::chrono::nanoseconds>(t1 - t0).count());
+    }
+
+    return run_bench("Cancel (random)", n, latencies);
+}
+
+// ─── Benchmark 4: Snapshot ──────────────────────────────────────────────────
+
+static BenchResult bench_snapshot(int n) {
+    OrderBook book("BENCH");
+
+    // Build a book with many levels
+    for (int i = 0; i < 500; ++i) {
+        Order buy, sell;
+        buy.id     = i * 2 + 1; buy.symbol = "BENCH"; buy.side = Side::BUY;
+        buy.type   = OrderType::LIMIT; buy.price = to_price(100.0 - i * 0.01); buy.qty = 100;
+
+        sell.id    = i * 2 + 2; sell.symbol = "BENCH"; sell.side = Side::SELL;
+        sell.type  = OrderType::LIMIT; sell.price = to_price(101.0 + i * 0.01); sell.qty = 100;
+
+        book.add_order(buy);
+        book.add_order(sell);
+    }
+
+    std::vector<int64_t> latencies;
+    latencies.reserve(n);
+
+    for (int i = 0; i < n; ++i) {
+        auto t0 = Clock::now();
+        auto snap = book.snapshot(10);
+        auto t1 = Clock::now();
+        latencies.push_back(std::chrono::duration_cast<std::chrono::nanoseconds>(t1 - t0).count());
+        (void)snap;
+    }
+
+    return run_bench("Snapshot (10 levels)", n, latencies);
+}
+
+// ─── Benchmark 5: Full Pipeline (submit_order via ExchangeSimulator) ────────
+
+static BenchResult bench_full_pipeline(int n) {
+    RiskLimits limits;
+    limits.max_order_qty = 100000;
+    limits.max_position = 10000000;
+    limits.max_notional_usd = 1e12;
+    limits.max_orders_per_sec = 1000000;
+
+    ExchangeSimulator sim(limits);
+    sim.add_symbol("BENCH");
+
+    std::mt19937 rng(789);
+    std::uniform_int_distribution<int> price_dist(9900, 10100);
+    std::uniform_int_distribution<int> qty_dist(1, 10);
+    std::vector<int64_t> latencies;
+    latencies.reserve(n);
+
+    for (int i = 0; i < n; ++i) {
+        Order o;
+        o.id     = sim.next_order_id();
+        o.symbol = "BENCH";
+        o.side   = (i % 2 == 0) ? Side::BUY : Side::SELL;
+        o.type   = OrderType::LIMIT;
+        o.price  = to_price(price_dist(rng) * 0.01);  // ~99.00 - 101.00
+        o.qty    = qty_dist(rng);
+
+        auto t0 = Clock::now();
+        sim.submit_order(o);
+        auto t1 = Clock::now();
+        latencies.push_back(std::chrono::duration_cast<std::chrono::nanoseconds>(t1 - t0).count());
+    }
+
+    return run_bench("Full pipeline (risk+match)", n, latencies);
+}
+
+// ─── Benchmark 6: Backtest Throughput ────────────────────────────────────────
+
+static void bench_backtest_throughput() {
+    std::cout << "\n--- Backtest Throughput ---\n";
+
+    int ticks = 50000;
+    MarketDataParser::Config cfg;
+    cfg.symbol = "BENCH"; cfg.start_price = 100.0;
+    cfg.ticks = ticks; cfg.volatility = 0.001; cfg.seed = 42;
+    auto tick_data = MarketDataParser::generate_synthetic(cfg);
+
+    RiskLimits rl;
+    rl.max_order_qty = 10000;
+    rl.max_position = 1000000;
+    rl.max_notional_usd = 1e12;
+    rl.max_orders_per_sec = 100000;
+
+    auto t0 = Clock::now();
+
+    Backtester bt(rl);
+    bt.add_symbol("BENCH");
+    bt.set_strategy(std::make_unique<MarketMakingStrategy>(5.0, 100));
+    auto result = bt.run(tick_data, false);
+
+    auto t1 = Clock::now();
+    double elapsed_s = std::chrono::duration<double>(t1 - t0).count();
+    double throughput = ticks / elapsed_s;
+
+    std::cout << "  Ticks:       " << ticks << "\n";
+    std::cout << "  Elapsed:     " << std::fixed << std::setprecision(3) << elapsed_s << " s\n";
+    std::cout << "  Throughput:  " << std::setprecision(0) << throughput << " ticks/s\n";
+    std::cout << "  Orders:      " << result.orders_submitted << "\n";
+    std::cout << "  Fills:       " << result.orders_filled << "\n";
+    std::cout << "  Trades:      " << result.trades_count << "\n";
+    std::cout << "  PnL:         " << std::setprecision(2) << result.total_pnl << "\n";
+}
+
+// ─── Main ────────────────────────────────────────────────────────────────────
+
+int main() {
+    std::cout << "\n";
+    std::cout << "╔════════════════════════════════════════════════════���══════════════════════════════════════════════════════════════╗\n";
+    std::cout << "║                              Orderflow Replay Engine — Performance Benchmark                                    ║\n";
+    std::cout << "╚═══════════════════════════════════════════════════════════════════════════════════════════════════════════════════╝\n\n";
+
+    const int N = 100000;
+
+    std::vector<BenchResult> results;
+    results.push_back(bench_insert_no_match(N));
+    results.push_back(bench_match(N));
+    results.push_back(bench_cancel(N));
+    results.push_back(bench_snapshot(N));
+    results.push_back(bench_full_pipeline(N));
+
+    std::cout << "--- Latency Results (N = " << N << " ops each) ---\n\n";
+    for (auto& r : results) print_result(r);
+
+    bench_backtest_throughput();
+
+    std::cout << "\n--- Memory ---\n";
+    std::cout << "  sizeof(Order):           " << sizeof(Order) << " bytes\n";
+    std::cout << "  sizeof(Trade):           " << sizeof(Trade) << " bytes\n";
+    std::cout << "  sizeof(PriceLevel):      " << sizeof(PriceLevel) << " bytes\n";
+    std::cout << "  sizeof(MarketDataTick):  " << sizeof(MarketDataTick) << " bytes\n";
+
+    std::cout << "\nDone.\n\n";
+    return 0;
+}

index.html

@@ -0,0 +1,1278 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>HFT Exchange Simulator</title>
+<style>
+  @import url('https://fonts.googleapis.com/css2?family=JetBrains+Mono:wght@300;400;500;600;700&family=Space+Mono:wght@400;700&display=swap');
+
+  :root {
+    --bg:       #080c10;
+    --bg1:      #0d1219;
+    --bg2:      #121820;
+    --bg3:      #1a2230;
+    --border:   #1e2d3d;
+    --border2:  #253545;
+    --text:     #c8d8e8;
+    --dim:      #5a7a90;
+    --green:    #00e676;
+    --green2:   #00c853;
+    --red:      #ff1744;
+    --red2:     #d50000;
+    --yellow:   #ffea00;
+    --blue:     #40c4ff;
+    --purple:   #ea80fc;
+    --orange:   #ff9100;
+    --cyan:     #18ffff;
+    --accent:   #00e5ff;
+    --glow:     0 0 12px rgba(0,229,255,0.25);
+    --glow-g:   0 0 12px rgba(0,230,118,0.3);
+    --glow-r:   0 0 12px rgba(255,23,68,0.3);
+    --mono:     'JetBrains Mono', 'Space Mono', monospace;
+  }
+
+  * { box-sizing: border-box; margin: 0; padding: 0; }
+
+  body {
+    font-family: var(--mono);
+    background: var(--bg);
+    color: var(--text);
+    min-height: 100vh;
+    overflow-x: hidden;
+    font-size: 12px;
+  }
+
+  /* Scanline overlay */
+  body::before {
+    content: '';
+    position: fixed; inset: 0;
+    background: repeating-linear-gradient(0deg,
+      transparent, transparent 2px,
+      rgba(0,0,0,0.03) 2px, rgba(0,0,0,0.03) 4px);
+    pointer-events: none; z-index: 9999;
+  }
+
+  /* Header */
+  .header {
+    display: flex; align-items: center; justify-content: space-between;
+    padding: 10px 20px;
+    background: linear-gradient(90deg, #050a10 0%, #0d1825 50%, #050a10 100%);
+    border-bottom: 1px solid var(--accent);
+    box-shadow: 0 0 30px rgba(0,229,255,0.1);
+    position: sticky; top: 0; z-index: 100;
+  }
+
+  .logo {
+    font-size: 15px; font-weight: 700; letter-spacing: 3px;
+    color: var(--accent);
+    text-shadow: 0 0 20px rgba(0,229,255,0.6);
+  }
+  .logo span { color: var(--green); }
+
+  .header-stats {
+    display: flex; gap: 24px;
+  }
+  .hstat { text-align: center; }
+  .hstat-label { font-size: 9px; color: var(--dim); text-transform: uppercase; letter-spacing: 1px; }
+  .hstat-val { font-size: 13px; font-weight: 600; }
+
+  .conn-dot {
+    width: 8px; height: 8px; border-radius: 50%;
+    background: var(--green);
+    box-shadow: 0 0 8px var(--green);
+    animation: pulse 2s ease-in-out infinite;
+  }
+  @keyframes pulse {
+    0%,100% { opacity: 1; } 50% { opacity: 0.4; }
+  }
+
+  /* Main grid */
+  .grid {
+    display: grid;
+    grid-template-columns: 320px 1fr 300px;
+    grid-template-rows: auto auto auto;
+    gap: 1px;
+    background: var(--border);
+    height: calc(100vh - 48px);
+  }
+
+  .panel {
+    background: var(--bg1);
+    overflow: hidden;
+    display: flex; flex-direction: column;
+  }
+
+  .panel-title {
+    font-size: 9px; font-weight: 700;
+    text-transform: uppercase; letter-spacing: 2px;
+    color: var(--dim);
+    padding: 8px 14px;
+    border-bottom: 1px solid var(--border);
+    display: flex; align-items: center; justify-content: space-between;
+    background: var(--bg2);
+    flex-shrink: 0;
+  }
+  .panel-title .tag {
+    font-size: 8px; padding: 2px 6px;
+    background: var(--bg3); border-radius: 2px;
+    color: var(--accent); letter-spacing: 1px;
+  }
+
+  .panel-body { flex: 1; overflow-y: auto; padding: 12px; }
+  .panel-body::-webkit-scrollbar { width: 3px; }
+  .panel-body::-webkit-scrollbar-track { background: var(--bg1); }
+  .panel-body::-webkit-scrollbar-thumb { background: var(--border2); border-radius: 2px; }
+
+  /* ORDER BOOK */
+  .book-header {
+    display: grid; grid-template-columns: 1fr 80px 80px;
+    font-size: 9px; color: var(--dim); letter-spacing: 1px;
+    padding: 4px 12px; border-bottom: 1px solid var(--border);
+    text-transform: uppercase;
+  }
+
+  .book-row {
+    display: grid; grid-template-columns: 1fr 80px 80px;
+    padding: 3px 12px;
+    position: relative; cursor: default;
+    transition: background 0.1s;
+  }
+  .book-row:hover { background: rgba(255,255,255,0.03); }
+
+  .book-bar {
+    position: absolute; top: 0; bottom: 0;
+    opacity: 0.12; pointer-events: none;
+    transition: width 0.3s ease;
+  }
+
+  .ask-row .book-bar { background: var(--red); right: 0; }
+  .bid-row .book-bar { background: var(--green); left: 0; }
+
+  .ask-row .price { color: var(--red); font-weight: 600; }
+  .bid-row .price { color: var(--green); font-weight: 600; }
+  .qty-val { text-align: right; color: var(--text); }
+  .orders-val { text-align: right; color: var(--dim); }
+
+  .spread-row {
+    display: flex; align-items: center; justify-content: center;
+    padding: 4px; font-size: 9px; color: var(--yellow);
+    border-top: 1px solid var(--border); border-bottom: 1px solid var(--border);
+    background: var(--bg2);
+    letter-spacing: 2px;
+  }
+
+  /* ORDER ENTRY */
+  .tabs {
+    display: flex; border-bottom: 1px solid var(--border);
+    flex-shrink: 0;
+  }
+  .tab {
+    flex: 1; padding: 8px; font-family: var(--mono); font-size: 9px;
+    font-weight: 700; letter-spacing: 1px; text-transform: uppercase;
+    border: none; cursor: pointer;
+    transition: all 0.2s;
+    background: var(--bg2); color: var(--dim);
+  }
+  .tab.active-buy { background: rgba(0,230,118,0.1); color: var(--green); border-bottom: 2px solid var(--green); }
+  .tab.active-sell { background: rgba(255,23,68,0.1); color: var(--red); border-bottom: 2px solid var(--red); }
+  .tab:hover { background: var(--bg3); }
+
+  .form-group { margin-bottom: 10px; }
+  label { font-size: 9px; color: var(--dim); text-transform: uppercase; letter-spacing: 1px; display: block; margin-bottom: 4px; }
+
+  input, select {
+    width: 100%; padding: 8px 10px;
+    background: var(--bg3); border: 1px solid var(--border2);
+    color: var(--text); font-family: var(--mono); font-size: 12px;
+    border-radius: 2px; outline: none;
+    transition: border-color 0.2s, box-shadow 0.2s;
+  }
+  input:focus, select:focus {
+    border-color: var(--accent);
+    box-shadow: var(--glow);
+  }
+  select option { background: var(--bg2); }
+
+  .btn {
+    width: 100%; padding: 10px;
+    font-family: var(--mono); font-size: 11px; font-weight: 700;
+    letter-spacing: 2px; text-transform: uppercase;
+    border: none; border-radius: 2px; cursor: pointer;
+    transition: all 0.2s; margin-top: 4px;
+  }
+  .btn-buy {
+    background: linear-gradient(135deg, #00c853, #00e676);
+    color: #001a0a;
+    box-shadow: 0 0 15px rgba(0,230,118,0.3);
+  }
+  .btn-buy:hover { box-shadow: 0 0 25px rgba(0,230,118,0.5); transform: translateY(-1px); }
+  .btn-sell {
+    background: linear-gradient(135deg, #d50000, #ff1744);
+    color: #1a0000;
+    box-shadow: 0 0 15px rgba(255,23,68,0.3);
+  }
+  .btn-sell:hover { box-shadow: 0 0 25px rgba(255,23,68,0.5); transform: translateY(-1px); }
+  .btn-neutral {
+    background: var(--bg3); color: var(--text);
+    border: 1px solid var(--border2);
+  }
+  .btn-neutral:hover { border-color: var(--accent); color: var(--accent); }
+  .btn-accent {
+    background: linear-gradient(135deg, #006080, #00acc1);
+    color: #001a20;
+    box-shadow: 0 0 15px rgba(0,229,255,0.2);
+  }
+  .btn-accent:hover { box-shadow: 0 0 25px rgba(0,229,255,0.4); transform: translateY(-1px); }
+
+  /* PRICE CHART */
+  canvas { display: block; }
+  #price-canvas { width: 100%; }
+
+  /* LATENCY / STATS */
+  .stat-row {
+    display: flex; justify-content: space-between;
+    padding: 5px 0; border-bottom: 1px solid rgba(30,45,61,0.5);
+  }
+  .stat-key { color: var(--dim); font-size: 10px; }
+  .stat-val { font-weight: 600; font-size: 11px; }
+  .green { color: var(--green); }
+  .red { color: var(--red); }
+  .yellow { color: var(--yellow); }
+  .blue { color: var(--blue); }
+  .cyan { color: var(--cyan); }
+
+  /* TRADE LOG */
+  .trade-entry {
+    display: flex; gap: 8px; padding: 5px 0;
+    border-bottom: 1px solid rgba(30,45,61,0.4);
+    font-size: 10px; align-items: center;
+    animation: fadeIn 0.3s ease;
+  }
+  @keyframes fadeIn { from { opacity: 0; transform: translateX(-5px); } to { opacity: 1; transform: translateX(0); } }
+
+  .trade-side {
+    padding: 2px 5px; font-size: 8px; font-weight: 700;
+    letter-spacing: 1px; border-radius: 2px;
+    min-width: 30px; text-align: center;
+  }
+  .buy-badge { background: rgba(0,230,118,0.15); color: var(--green); }
+  .sell-badge { background: rgba(255,23,68,0.15); color: var(--red); }
+
+  /* POSITION TABLE */
+  .pos-table { width: 100%; border-collapse: collapse; font-size: 10px; }
+  .pos-table th { 
+    text-align: left; padding: 4px 6px; 
+    color: var(--dim); font-size: 8px; text-transform: uppercase; letter-spacing: 1px;
+    border-bottom: 1px solid var(--border);
+  }
+  .pos-table td { padding: 5px 6px; border-bottom: 1px solid rgba(30,45,61,0.3); }
+
+  /* BACKTEST PANEL */
+  .bt-result {
+    background: var(--bg2); border: 1px solid var(--border2);
+    border-radius: 3px; padding: 10px; margin-top: 10px;
+  }
+  .bt-metric { 
+    display: flex; justify-content: space-between; 
+    padding: 3px 0; font-size: 10px;
+  }
+
+  /* EQUITY CURVE */
+  #equity-canvas { width: 100%; border-top: 1px solid var(--border); }
+
+  /* LATENCY BARS */
+  .lat-bar-wrap { margin: 4px 0; }
+  .lat-bar-label { display: flex; justify-content: space-between; font-size: 9px; margin-bottom: 2px; }
+  .lat-bar { height: 6px; background: var(--bg3); border-radius: 3px; overflow: hidden; }
+  .lat-bar-fill { height: 100%; border-radius: 3px; transition: width 0.5s ease; }
+
+  /* RISK PANEL */
+  .risk-meter {
+    height: 8px; background: var(--bg3); border-radius: 4px; overflow: hidden;
+    margin: 4px 0 10px;
+  }
+  .risk-fill {
+    height: 100%; border-radius: 4px; transition: width 0.5s ease;
+  }
+
+  /* FEED CONTROL */
+  .feed-control {
+    display: flex; gap: 6px; padding: 8px 12px;
+    border-top: 1px solid var(--border);
+    flex-shrink: 0;
+  }
+  .feed-control .btn { margin: 0; flex: 1; padding: 7px; font-size: 9px; }
+
+  /* Symbol selector strip */
+  .sym-strip {
+    display: flex; gap: 4px; padding: 6px 12px;
+    border-bottom: 1px solid var(--border);
+    overflow-x: auto; flex-shrink: 0;
+  }
+  .sym-btn {
+    padding: 3px 10px; font-family: var(--mono); font-size: 9px;
+    font-weight: 700; letter-spacing: 1px; text-transform: uppercase;
+    border: 1px solid var(--border2); border-radius: 2px;
+    cursor: pointer; background: var(--bg3); color: var(--dim);
+    transition: all 0.15s; white-space: nowrap;
+  }
+  .sym-btn.active, .sym-btn:hover {
+    border-color: var(--accent); color: var(--accent);
+    background: rgba(0,229,255,0.08);
+  }
+
+  /* Notification toast */
+  .toast {
+    position: fixed; top: 60px; right: 20px;
+    background: var(--bg2); border: 1px solid var(--accent);
+    padding: 10px 16px; border-radius: 3px;
+    font-size: 11px; z-index: 1000;
+    animation: toastIn 0.3s ease, toastOut 0.3s ease 2.7s forwards;
+    box-shadow: var(--glow);
+  }
+  @keyframes toastIn { from { opacity: 0; transform: translateX(20px); } to { opacity: 1; transform: translateX(0); } }
+  @keyframes toastOut { to { opacity: 0; transform: translateX(20px); } }
+
+  /* Scrollable sections */
+  .scroll-area { flex: 1; overflow-y: auto; }
+  .scroll-area::-webkit-scrollbar { width: 3px; }
+  .scroll-area::-webkit-scrollbar-thumb { background: var(--border2); }
+
+  /* Responsive col spans */
+  .span2 { grid-column: span 2; }
+  .col-left { grid-column: 1; grid-row: 1 / span 3; }
+  .col-mid  { grid-column: 2; }
+  .col-right { grid-column: 3; grid-row: 1 / span 3; }
+
+  .grid-inner {
+    display: grid;
+    grid-template-columns: 320px 1fr 300px;
+    grid-template-rows: 360px 260px 1fr;
+    gap: 1px;
+    background: var(--border);
+    height: calc(100vh - 48px);
+  }
+
+  /* Alert for rejected orders */
+  .rejected { border-left: 3px solid var(--red) !important; animation: shake 0.3s; }
+  @keyframes shake {
+    0%,100% { transform: translateX(0); }
+    25% { transform: translateX(-4px); }
+    75% { transform: translateX(4px); }
+  }
+
+  /* Blinking cursor */
+  .cursor::after { content: '█'; animation: blink 1s step-end infinite; color: var(--accent); }
+  @keyframes blink { 50% { opacity: 0; } }
+
+  /* Number animations */
+  .num-up { animation: numUp 0.4s ease; }
+  .num-down { animation: numDown 0.4s ease; }
+  @keyframes numUp { 0% { color: var(--green); } 100% { color: inherit; } }
+  @keyframes numDown { 0% { color: var(--red); } 100% { color: inherit; } }
+
+  /* Progress ring for latency */
+  .ring-wrap { position: relative; display: inline-flex; align-items: center; justify-content: center; }
+
+  /* Hover row highlight for order book */
+  .book-asks .book-row:hover .price { text-shadow: 0 0 8px var(--red); }
+  .book-bids .book-row:hover .price { text-shadow: 0 0 8px var(--green); }
+
+  /* Section divider */
+  .divider { height: 1px; background: var(--border); margin: 10px 0; }
+
+  /* Blinking red for reject */
+  .flash-red { animation: flashRed 0.5s; }
+  @keyframes flashRed { 0%,100% { background: var(--bg1); } 50% { background: rgba(255,23,68,0.15); } }
+
+  /* Toggle switch */
+  .toggle { position: relative; display: inline-flex; align-items: center; gap: 8px; cursor: pointer; }
+  .toggle input { display: none; }
+  .toggle-track {
+    width: 32px; height: 16px; background: var(--bg3);
+    border: 1px solid var(--border2); border-radius: 8px;
+    transition: background 0.2s;
+    position: relative;
+  }
+  .toggle input:checked + .toggle-track { background: var(--green2); border-color: var(--green); }
+  .toggle-thumb {
+    position: absolute; top: 1px; left: 1px;
+    width: 12px; height: 12px; border-radius: 6px;
+    background: var(--dim); transition: transform 0.2s, background 0.2s;
+  }
+  .toggle input:checked ~ .toggle-thumb {
+    transform: translateX(16px); background: white;
+  }
+
+  .mode-tabs { display: flex; gap: 1px; border-bottom: 1px solid var(--border); flex-shrink: 0; }
+  .mode-tab {
+    flex: 1; padding: 6px; font-family: var(--mono); font-size: 9px; font-weight: 700;
+    letter-spacing: 1px; text-transform: uppercase; border: none; cursor: pointer;
+    background: var(--bg2); color: var(--dim); transition: all 0.15s;
+  }
+  .mode-tab.active { background: var(--bg3); color: var(--accent); border-bottom: 1px solid var(--accent); }
+</style>
+</head>
+<body>
+
+<!-- HEADER -->
+<div class="header">
+  <div style="display:flex;align-items:center;gap:16px">
+    <div class="conn-dot" id="conn-dot"></div>
+    <div class="logo">HFT<span>·</span>EXCHANGE<span>·</span>SIM</div>
+    <div style="font-size:9px;color:var(--dim);letter-spacing:1px">C++ MATCHING ENGINE</div>
+  </div>
+  <div class="header-stats">
+    <div class="hstat"><div class="hstat-label">Orders</div><div class="hstat-val cyan" id="h-orders">0</div></div>
+    <div class="hstat"><div class="hstat-label">Trades</div><div class="hstat-val green" id="h-trades">0</div></div>
+    <div class="hstat"><div class="hstat-label">Rejects</div><div class="hstat-val red" id="h-rejects">0</div></div>
+    <div class="hstat"><div class="hstat-label">P&L</div><div class="hstat-val" id="h-pnl">$0.00</div></div>
+    <div class="hstat"><div class="hstat-label">p99 Latency</div><div class="hstat-val yellow" id="h-p99">—</div></div>
+    <div class="hstat"><div class="hstat-label">Throughput</div><div class="hstat-val blue" id="h-thru">—</div></div>
+  </div>
+</div>
+
+<!-- MAIN GRID -->
+<div class="grid-inner">
+
+  <!-- COL 1: Order Book + Order Entry -->
+  <div class="panel" style="grid-column:1;grid-row:1/span 3;display:flex;flex-direction:column">
+
+    <!-- Symbol strip -->
+    <div class="sym-strip" id="sym-strip"></div>
+
+    <!-- Order Book -->
+    <div class="panel-title">
+      Order Book — L2 <span id="book-symbol-tag" class="tag">AAPL</span>
+    </div>
+    <div class="book-header">
+      <span>PRICE</span><span style="text-align:right">QTY</span><span style="text-align:right">ODS</span>
+    </div>
+
+    <div style="flex:1;overflow-y:auto;display:flex;flex-direction:column">
+      <div class="book-asks scroll-area" id="book-asks" style="flex:1;display:flex;flex-direction:column;justify-content:flex-end"></div>
+      <div class="spread-row" id="spread-row">SPREAD: —</div>
+      <div class="book-bids scroll-area" id="book-bids" style="flex:1"></div>
+    </div>
+
+    <!-- Order Entry -->
+    <div class="divider" style="margin:0"></div>
+    <div class="panel-title">Order Entry</div>
+
+    <div class="tabs">
+      <button class="tab active-buy" id="tab-buy" onclick="setOrderSide('BUY')">▲ BUY</button>
+      <button class="tab" id="tab-sell" onclick="setOrderSide('SELL')">▼ SELL</button>
+    </div>
+
+    <div style="padding:12px;flex-shrink:0">
+      <div class="form-group">
+        <label>Type</label>
+        <select id="oe-type" onchange="updateOrderForm()">
+          <option value="LIMIT">LIMIT</option>
+          <option value="MARKET">MARKET</option>
+          <option value="IOC">IOC (Immediate-Or-Cancel)</option>
+          <option value="FOK">FOK (Fill-Or-Kill)</option>
+        </select>
+      </div>
+      <div class="form-group">
+        <label>Symbol</label>
+        <select id="oe-symbol">
+          <option>AAPL</option><option>GOOG</option><option>MSFT</option>
+          <option>TSLA</option><option>NVDA</option>
+        </select>
+      </div>
+      <div class="form-group" id="oe-price-group">
+        <label>Price</label>
+        <input type="number" id="oe-price" step="0.01" placeholder="0.00">
+      </div>
+      <div class="form-group">
+        <label>Quantity</label>
+        <input type="number" id="oe-qty" value="100" min="1">
+      </div>
+      <div class="form-group" style="display:none">
+        <label>Client ID (optional)</label>
+        <input type="text" id="oe-cid" placeholder="STRAT_01">
+      </div>
+      <button class="btn btn-buy" id="submit-btn" onclick="submitOrder()">▲ PLACE BUY ORDER</button>
+    </div>
+
+    <div class="feed-control">
+      <button class="btn btn-neutral" onclick="feedStep(10)">▶ +10 TICKS</button>
+      <button class="btn btn-neutral" onclick="feedStep(100)">▶▶ +100</button>
+      <button class="btn btn-accent" onclick="autoFeed()" id="auto-btn">AUTO</button>
+    </div>
+  </div>
+
+  <!-- COL 2, ROW 1: Price Chart -->
+  <div class="panel" style="grid-column:2;grid-row:1">
+    <div class="panel-title">
+      Price Feed — Real-time Tick
+      <div style="display:flex;gap:10px;align-items:center">
+        <span id="chart-symbol" class="tag">AAPL</span>
+        <span id="chart-price" style="font-size:13px;font-weight:700;color:var(--accent)">—</span>
+      </div>
+    </div>
+    <canvas id="price-canvas" height="290"></canvas>
+  </div>
+
+  <!-- COL 2, ROW 2: Latency / Throughput -->
+  <div class="panel" style="grid-column:2;grid-row:2">
+    <div class="panel-title">Latency Profiler <span class="tag">C++ ENGINE</span></div>
+    <div class="panel-body" style="display:grid;grid-template-columns:1fr 1fr;gap:16px">
+      <div>
+        <div style="font-size:9px;color:var(--dim);text-transform:uppercase;letter-spacing:1px;margin-bottom:8px">Order Latency</div>
+        <div class="lat-bar-wrap">
+          <div class="lat-bar-label"><span style="color:var(--dim)">p50</span><span id="lat-o-p50" style="color:var(--green)">—</span></div>
+          <div class="lat-bar"><div class="lat-bar-fill" id="lat-o-p50-bar" style="background:var(--green);width:0%"></div></div>
+        </div>
+        <div class="lat-bar-wrap">
+          <div class="lat-bar-label"><span style="color:var(--dim)">p99</span><span id="lat-o-p99" style="color:var(--yellow)">—</span></div>
+          <div class="lat-bar"><div class="lat-bar-fill" id="lat-o-p99-bar" style="background:var(--yellow);width:0%"></div></div>
+        </div>
+        <div class="lat-bar-wrap">
+          <div class="lat-bar-label"><span style="color:var(--dim)">avg</span><span id="lat-o-avg" style="color:var(--blue)">—</span></div>
+          <div class="lat-bar"><div class="lat-bar-fill" id="lat-o-avg-bar" style="background:var(--blue);width:0%"></div></div>
+        </div>
+        <div class="divider"></div>
+        <div class="stat-row"><span class="stat-key">Checked</span><span id="risk-checked" class="stat-val cyan">0</span></div>
+        <div class="stat-row"><span class="stat-key">Rejected</span><span id="risk-rejected" class="stat-val red">0</span></div>
+        <div class="stat-row"><span class="stat-key">Fill Rate</span><span id="fill-rate" class="stat-val green">0%</span></div>
+      </div>
+      <div>
+        <div style="font-size:9px;color:var(--dim);text-transform:uppercase;letter-spacing:1px;margin-bottom:8px">Tick Latency</div>
+        <div class="lat-bar-wrap">
+          <div class="lat-bar-label"><span style="color:var(--dim)">p50</span><span id="lat-t-p50" style="color:var(--green)">—</span></div>
+          <div class="lat-bar"><div class="lat-bar-fill" id="lat-t-p50-bar" style="background:var(--green);width:0%"></div></div>
+        </div>
+        <div class="lat-bar-wrap">
+          <div class="lat-bar-label"><span style="color:var(--dim)">p99</span><span id="lat-t-p99" style="color:var(--yellow)">—</span></div>
+          <div class="lat-bar"><div class="lat-bar-fill" id="lat-t-p99-bar" style="background:var(--yellow);width:0%"></div></div>
+        </div>
+        <div class="divider"></div>
+        <div class="stat-row"><span class="stat-key">Feed Size</span><span id="feed-size" class="stat-val">—</span></div>
+        <div class="stat-row"><span class="stat-key">Feed Index</span><span id="feed-idx" class="stat-val">—</span></div>
+        <div class="stat-row"><span class="stat-key">Total P&L</span><span id="stat-pnl" class="stat-val">—</span></div>
+      </div>
+    </div>
+  </div>
+
+  <!-- COL 2, ROW 3: Trade Log -->
+  <div class="panel" style="grid-column:2;grid-row:3">
+    <div class="panel-title">
+      Trade Log
+      <div style="display:flex;gap:8px">
+        <span id="trade-count" class="tag">0 trades</span>
+        <button class="btn btn-neutral" style="padding:2px 8px;font-size:8px;margin:0;width:auto" onclick="resetSim()">RESET</button>
+      </div>
+    </div>
+    <div class="scroll-area" style="flex:1" id="trade-log"></div>
+  </div>
+
+  <!-- COL 3: Positions + Backtest + Risk -->
+  <div class="panel" style="grid-column:3;grid-row:1/span 3;display:flex;flex-direction:column">
+
+    <div class="mode-tabs">
+      <button class="mode-tab active" onclick="setRightMode('positions')">POSITIONS</button>
+      <button class="mode-tab" onclick="setRightMode('backtest')">BACKTEST</button>
+      <button class="mode-tab" onclick="setRightMode('risk')">RISK</button>
+    </div>
+
+    <!-- POSITIONS VIEW -->
+    <div id="view-positions" style="flex:1;overflow:hidden;display:flex;flex-direction:column">
+      <div class="panel-title">Live Positions</div>
+      <div class="panel-body" style="overflow:auto">
+        <table class="pos-table" id="pos-table">
+          <thead><tr>
+            <th>SYM</th><th>POS</th><th>AVG PX</th><th>RPNL</th><th>UPNL</th>
+          </tr></thead>
+          <tbody id="pos-body"></tbody>
+        </table>
+        <div class="divider"></div>
+        <div style="font-size:9px;color:var(--dim);text-transform:uppercase;letter-spacing:1px;margin-bottom:6px">Recent Orders</div>
+        <div id="order-log" style="max-height:200px;overflow-y:auto"></div>
+      </div>
+    </div>
+
+    <!-- BACKTEST VIEW -->
+    <div id="view-backtest" style="flex:1;overflow:hidden;display:flex;flex-direction:column;display:none">
+      <div class="panel-title">Backtest Engine <span class="tag">DETERMINISTIC</span></div>
+      <div class="panel-body" style="overflow:auto">
+        <div class="form-group">
+          <label>Strategy</label>
+          <select id="bt-strategy">
+            <option value="MarketMaking">Market Making (MM)</option>
+            <option value="Momentum">Momentum (EMA Cross)</option>
+            <option value="MeanReversion">Mean Reversion (Z-Score)</option>
+          </select>
+        </div>
+        <div class="form-group">
+          <label>Symbol</label>
+          <select id="bt-symbol">
+            <option>AAPL</option><option>GOOG</option><option>MSFT</option>
+            <option>TSLA</option><option>NVDA</option>
+          </select>
+        </div>
+        <div class="form-group">
+          <label>Ticks to Replay</label>
+          <input type="number" id="bt-ticks" value="5000" min="200" max="50000">
+        </div>
+        <div class="form-group">
+          <label>Start Price</label>
+          <input type="number" id="bt-price" value="185.00" step="0.01">
+        </div>
+        <button class="btn btn-accent" onclick="runBacktest()" id="bt-btn">▶ RUN BACKTEST</button>
+
+        <div id="bt-result" style="display:none" class="bt-result">
+          <div style="font-size:9px;color:var(--dim);letter-spacing:1px;margin-bottom:8px">BACKTEST RESULTS</div>
+          <div class="bt-metric"><span class="stat-key">Strategy</span><span id="bt-r-strategy" class="stat-val cyan"></span></div>
+          <div class="bt-metric"><span class="stat-key">Ticks</span><span id="bt-r-ticks" class="stat-val"></span></div>
+          <div class="bt-metric"><span class="stat-key">Orders</span><span id="bt-r-orders" class="stat-val"></span></div>
+          <div class="bt-metric"><span class="stat-key">Fills</span><span id="bt-r-fills" class="stat-val green"></span></div>
+          <div class="bt-metric"><span class="stat-key">Rejected</span><span id="bt-r-rej" class="stat-val red"></span></div>
+          <div class="bt-metric"><span class="stat-key">Trades</span><span id="bt-r-trades" class="stat-val"></span></div>
+          <div class="bt-metric"><span class="stat-key">Total P&L</span><span id="bt-r-pnl" class="stat-val"></span></div>
+          <div class="bt-metric"><span class="stat-key">Max Drawdown</span><span id="bt-r-dd" class="stat-val red"></span></div>
+          <div class="bt-metric"><span class="stat-key">Sharpe</span><span id="bt-r-sharpe" class="stat-val yellow"></span></div>
+          <div class="bt-metric"><span class="stat-key">Order p50</span><span id="bt-r-p50" class="stat-val green"></span></div>
+          <div class="bt-metric"><span class="stat-key">Order p99</span><span id="bt-r-p99" class="stat-val yellow"></span></div>
+          <div class="bt-metric"><span class="stat-key">Throughput</span><span id="bt-r-thru" class="stat-val blue"></span></div>
+          <canvas id="equity-canvas" height="100" style="margin-top:10px;width:100%;border:1px solid var(--border)"></canvas>
+        </div>
+      </div>
+    </div>
+
+    <!-- RISK VIEW -->
+    <div id="view-risk" style="flex:1;overflow:hidden;display:flex;flex-direction:column;display:none">
+      <div class="panel-title">Pre-Trade Risk <span class="tag">LIVE</span></div>
+      <div class="panel-body" style="overflow:auto">
+        <div class="form-group">
+          <label>Max Order Qty</label>
+          <input type="number" id="r-max-qty" value="10000">
+        </div>
+        <div class="form-group">
+          <label>Max Position</label>
+          <input type="number" id="r-max-pos" value="500000">
+        </div>
+        <div class="form-group">
+          <label>Max Notional ($)</label>
+          <input type="number" id="r-max-notional" value="50000000">
+        </div>
+        <div class="form-group">
+          <label>Max Orders/sec</label>
+          <input type="number" id="r-max-rate" value="2000">
+        </div>
+        <button class="btn btn-accent" onclick="setRiskLimits()">UPDATE LIMITS</button>
+
+        <div class="divider"></div>
+        <div style="font-size:9px;color:var(--dim);text-transform:uppercase;letter-spacing:1px;margin-bottom:8px">Risk Utilization</div>
+        <div class="lat-bar-wrap">
+          <div class="lat-bar-label"><span style="color:var(--dim)">Order Rate</span><span id="r-rate-pct" style="color:var(--yellow)">0%</span></div>
+          <div class="lat-bar"><div class="lat-bar-fill" id="r-rate-bar" style="width:0%;background:var(--yellow)"></div></div>
+        </div>
+        <div class="lat-bar-wrap">
+          <div class="lat-bar-label"><span style="color:var(--dim)">Reject Rate</span><span id="r-rej-pct" style="color:var(--red)">0%</span></div>
+          <div class="lat-bar"><div class="lat-bar-fill" id="r-rej-bar" style="width:0%;background:var(--red)"></div></div>
+        </div>
+        <div class="divider"></div>
+        <div class="stat-row"><span class="stat-key">Checked</span><span id="r-checked" class="stat-val">0</span></div>
+        <div class="stat-row"><span class="stat-key">Approved</span><span id="r-approved" class="stat-val green">0</span></div>
+        <div class="stat-row"><span class="stat-key">Rejected</span><span id="r-rejected2" class="stat-val red">0</span></div>
+
+        <div class="divider"></div>
+        <div style="font-size:9px;color:var(--dim);text-transform:uppercase;letter-spacing:1px;margin-bottom:8px">Risk Check Types</div>
+        <div style="font-size:10px;color:var(--text);line-height:1.8">
+          ✓ Max Order Size<br>
+          ✓ Max Position Limit<br>
+          ✓ Max Notional Exposure<br>
+          ✓ Max Order Rate (1s window)<br>
+          ✓ Invalid Price/Qty<br>
+          ✓ Symbol Validation
+        </div>
+      </div>
+    </div>
+
+  </div>
+</div>
+
+<script>
+// ── State ─────────────────────────────────────────────────────────────────────
+const API = '';
+let selectedSymbol = 'AAPL';
+let orderSide = 'BUY';
+let autoFeedInterval = null;
+let priceHistory = {}; // symbol -> [{ts, price}]
+let rightMode = 'positions';
+
+// Price chart
+const priceCtx = document.getElementById('price-canvas');
+let priceChart = null;
+
+// ── Init ──────────────────────────────────────────────────────────────────────
+window.addEventListener('DOMContentLoaded', () => {
+  buildSymbolStrip();
+  selectSymbol('AAPL');
+  startPolling();
+  feedStep(50); // warm up
+});
+
+function buildSymbolStrip() {
+  const syms = ['AAPL','GOOG','MSFT','TSLA','NVDA'];
+  const strip = document.getElementById('sym-strip');
+  strip.innerHTML = syms.map(s =>
+    `<button class="sym-btn ${s===selectedSymbol?'active':''}" onclick="selectSymbol('${s}')">${s}</button>`
+  ).join('');
+}
+
+function selectSymbol(sym) {
+  selectedSymbol = sym;
+  document.getElementById('oe-symbol').value = sym;
+  document.getElementById('book-symbol-tag').textContent = sym;
+  document.getElementById('chart-symbol').textContent = sym;
+  buildSymbolStrip();
+  refreshBook();
+  refreshChart();
+}
+
+// ── API calls ─────────────────────────────────────────────────────────────────
+async function api(method, path, body=null) {
+  const opts = { method, headers: {'Content-Type':'application/json'} };
+  if (body) opts.body = JSON.stringify(body);
+  const r = await fetch(API + path, opts);
+  return r.json();
+}
+
+// ── Polling ───────────────────────────────────────────────────────────────────
+function startPolling() {
+  refreshStatus();
+  refreshBook();
+  refreshPositions();
+  refreshTrades();
+  setInterval(refreshStatus, 1500);
+  setInterval(refreshBook, 500);
+  setInterval(refreshPositions, 2000);
+  setInterval(refreshTrades, 1000);
+}
+
+async function refreshStatus() {
+  const d = await api('GET', '/api/status');
+  if (d.error) return;
+
+  setVal('h-orders',  d.total_orders);
+  setVal('h-trades',  d.total_trades);
+  setVal('h-rejects', d.total_rejects);
+
+  const pnl = d.total_pnl || 0;
+  const pnlEl = document.getElementById('h-pnl');
+  pnlEl.textContent = '$' + pnl.toFixed(2);
+  pnlEl.className = 'hstat-val ' + (pnl >= 0 ? 'green' : 'red');
+
+  const p99 = d.order_p99_us || 0;
+  document.getElementById('h-p99').textContent = p99 > 0 ? p99.toFixed(1)+'µs' : '—';
+
+  // Latency bars (relative to 1000µs max)
+  setLatBar('lat-o-p50', 'lat-o-p50-bar', d.order_p50_us, 500);
+  setLatBar('lat-o-p99', 'lat-o-p99-bar', d.order_p99_us, 500);
+  setLatBar('lat-t-p50', 'lat-t-p50-bar', d.tick_p50_us, 100);
+  setLatBar('lat-t-p99', 'lat-t-p99-bar', d.tick_p99_us, 100);
+
+  setVal('risk-checked',  d.risk_checked);
+  setVal('risk-rejected', d.risk_rejected);
+  setVal('r-checked',     d.risk_checked);
+  setVal('r-rejected2',   d.risk_rejected);
+  setVal('r-approved',    Math.max(0, d.risk_checked - d.risk_rejected));
+
+  const fillRate = d.total_orders > 0
+    ? ((d.total_trades / d.total_orders) * 100).toFixed(1)+'%'
+    : '0%';
+  document.getElementById('fill-rate').textContent = fillRate;
+
+  setVal('feed-size', d.feed_size);
+  setVal('feed-idx',  d.feed_idx);
+
+  const pnlEl2 = document.getElementById('stat-pnl');
+  pnlEl2.textContent = '$' + pnl.toFixed(2);
+  pnlEl2.className = 'stat-val ' + (pnl >= 0 ? 'green' : 'red');
+
+  // Reject rate bar
+  if (d.risk_checked > 0) {
+    const rejPct = (d.risk_rejected / d.risk_checked * 100);
+    setBarWidth('r-rej-bar', rejPct);
+    document.getElementById('r-rej-pct').textContent = rejPct.toFixed(1)+'%';
+  }
+
+  // Connection indicator
+  document.getElementById('conn-dot').style.background = 'var(--green)';
+}
+
+function setLatBar(valId, barId, val, maxVal) {
+  const el = document.getElementById(valId);
+  const bar = document.getElementById(barId);
+  if (!el || !bar) return;
+  if (val === undefined || val === null) return;
+  el.textContent = val > 0 ? val.toFixed(2)+'µs' : '< 1µs';
+  const pct = Math.min(100, (val / maxVal) * 100);
+  bar.style.width = pct + '%';
+}
+
+function setBarWidth(id, pct) {
+  const el = document.getElementById(id);
+  if (el) el.style.width = Math.min(100, pct) + '%';
+}
+
+function setVal(id, val) {
+  const el = document.getElementById(id);
+  if (el) el.textContent = val;
+}
+
+// ── Order Book ────────────────────────────────────────────────────────────────
+async function refreshBook() {
+  const d = await api('GET', `/api/book/${selectedSymbol}`);
+  if (d.error || !d.asks) return;
+  renderBook(d);
+}
+
+function renderBook(d) {
+  const maxQty = Math.max(
+    ...(d.bids||[]).map(b=>b.qty),
+    ...(d.asks||[]).map(a=>a.qty), 1
+  );
+
+  // Asks: show in ascending order but display reversed (best ask at bottom)
+  const asks = (d.asks||[]).slice(0,10);
+  const asksEl = document.getElementById('book-asks');
+  asksEl.innerHTML = [...asks].reverse().map(a => {
+    const pct = (a.qty / maxQty * 100).toFixed(1);
+    return `<div class="book-row ask-row">
+      <div class="book-bar" style="width:${pct}%"></div>
+      <span class="price">${a.price.toFixed(4)}</span>
+      <span class="qty-val">${fmtNum(a.qty)}</span>
+      <span class="orders-val">${a.orders}</span>
+    </div>`;
+  }).join('');
+
+  const spreadEl = document.getElementById('spread-row');
+  if (d.spread > 0) {
+    spreadEl.textContent = `BID ${d.best_bid.toFixed(4)} ─── SPREAD ${d.spread.toFixed(4)} ─── ASK ${d.best_ask.toFixed(4)}`;
+  }
+
+  // Update chart price
+  const mid = d.mid || d.best_bid;
+  if (mid > 0) {
+    document.getElementById('chart-price').textContent = '$' + mid.toFixed(2);
+  }
+
+  const bids = (d.bids||[]).slice(0,10);
+  const bidsEl = document.getElementById('book-bids');
+  bidsEl.innerHTML = bids.map(b => {
+    const pct = (b.qty / maxQty * 100).toFixed(1);
+    return `<div class="book-row bid-row">
+      <div class="book-bar" style="width:${pct}%"></div>
+      <span class="price">${b.price.toFixed(4)}</span>
+      <span class="qty-val">${fmtNum(b.qty)}</span>
+      <span class="orders-val">${b.orders}</span>
+    </div>`;
+  }).join('');
+}
+
+// ── Price Chart ───────────────────────────────────────────────────────────────
+const MAX_HISTORY = 300;
+
+async function refreshChart() {
+  // Just use feed data from status — we'll seed from order book mid
+}
+
+function addPricePoint(sym, price, ts) {
+  if (!priceHistory[sym]) priceHistory[sym] = [];
+  priceHistory[sym].push({price, ts});
+  if (priceHistory[sym].length > MAX_HISTORY)
+    priceHistory[sym].shift();
+  if (sym === selectedSymbol) drawPriceChart();
+}
+
+function drawPriceChart() {
+  const canvas = document.getElementById('price-canvas');
+  const ctx = canvas.getContext('2d');
+  const W = canvas.parentElement.offsetWidth;
+  const H = 290;
+  canvas.width = W; canvas.height = H;
+
+  ctx.fillStyle = '#0d1219';
+  ctx.fillRect(0, 0, W, H);
+
+  const data = priceHistory[selectedSymbol] || [];
+  if (data.length < 2) {
+    ctx.fillStyle = '#1e2d3d';
+    ctx.font = '11px JetBrains Mono';
+    ctx.textAlign = 'center';
+    ctx.fillText('Feed ticks to populate chart', W/2, H/2);
+    return;
+  }
+
+  const prices = data.map(d => d.price);
+  const minP = Math.min(...prices);
+  const maxP = Math.max(...prices);
+  const range = maxP - minP || 1;
+  const pad = { t:20, r:60, b:30, l:10 };
+  const cW = W - pad.l - pad.r;
+  const cH = H - pad.t - pad.b;
+
+  const xOf = i => pad.l + (i / (data.length-1)) * cW;
+  const yOf = p => pad.t + (1 - (p - minP) / range) * cH;
+
+  // Grid lines
+  ctx.strokeStyle = '#1a2230';
+  ctx.lineWidth = 1;
+  for (let i = 0; i <= 4; i++) {
+    const y = pad.t + (i / 4) * cH;
+    ctx.beginPath(); ctx.moveTo(pad.l, y); ctx.lineTo(W - pad.r, y); ctx.stroke();
+    const price = maxP - (i / 4) * range;
+    ctx.fillStyle = '#5a7a90'; ctx.font = '9px JetBrains Mono';
+    ctx.textAlign = 'right';
+    ctx.fillText('$' + price.toFixed(2), W - 5, y + 3);
+  }
+
+  // Gradient fill
+  const grad = ctx.createLinearGradient(0, pad.t, 0, H - pad.b);
+  const last = data[data.length - 1];
+  const first = data[0];
+  const isUp = last.price >= first.price;
+  if (isUp) {
+    grad.addColorStop(0, 'rgba(0,230,118,0.2)');
+    grad.addColorStop(1, 'rgba(0,230,118,0.01)');
+  } else {
+    grad.addColorStop(0, 'rgba(255,23,68,0.2)');
+    grad.addColorStop(1, 'rgba(255,23,68,0.01)');
+  }
+
+  ctx.beginPath();
+  ctx.moveTo(xOf(0), yOf(data[0].price));
+  for (let i = 1; i < data.length; i++) {
+    const x1 = xOf(i-1), x2 = xOf(i);
+    const y1 = yOf(data[i-1].price), y2 = yOf(data[i].price);
+    const cpX = (x1 + x2) / 2;
+    ctx.bezierCurveTo(cpX, y1, cpX, y2, x2, y2);
+  }
+  ctx.lineTo(xOf(data.length-1), H - pad.b);
+  ctx.lineTo(xOf(0), H - pad.b);
+  ctx.closePath();
+  ctx.fillStyle = grad;
+  ctx.fill();
+
+  // Line
+  ctx.beginPath();
+  ctx.moveTo(xOf(0), yOf(data[0].price));
+  for (let i = 1; i < data.length; i++) {
+    const x1 = xOf(i-1), x2 = xOf(i);
+    const y1 = yOf(data[i-1].price), y2 = yOf(data[i].price);
+    const cpX = (x1 + x2) / 2;
+    ctx.bezierCurveTo(cpX, y1, cpX, y2, x2, y2);
+  }
+  ctx.strokeStyle = isUp ? '#00e676' : '#ff1744';
+  ctx.lineWidth = 2;
+  ctx.shadowColor = isUp ? '#00e676' : '#ff1744';
+  ctx.shadowBlur = 6;
+  ctx.stroke();
+  ctx.shadowBlur = 0;
+
+  // Last price dot
+  const lx = xOf(data.length - 1);
+  const ly = yOf(last.price);
+  ctx.beginPath(); ctx.arc(lx, ly, 4, 0, Math.PI*2);
+  ctx.fillStyle = isUp ? '#00e676' : '#ff1744';
+  ctx.fill();
+
+  // OHLC mini labels
+  ctx.fillStyle = '#5a7a90'; ctx.font = '9px JetBrains Mono';
+  ctx.textAlign = 'left';
+  ctx.fillText(`↑ ${maxP.toFixed(2)}`, pad.l + 5, pad.t + 12);
+  ctx.fillText(`↓ ${minP.toFixed(2)}`, pad.l + 5, H - pad.b - 5);
+}
+
+// ── Feed ──────────────────────────────────────────────────────────────────────
+async function feedStep(n) {
+  const ticks = await api('POST', '/api/feed/step', {n});
+  if (!Array.isArray(ticks)) return;
+  ticks.forEach(t => {
+    addPricePoint(t.symbol, t.last, t.ts);
+    if (t.symbol === selectedSymbol) {
+      document.getElementById('chart-price').textContent = '$' + t.last.toFixed(2);
+      // Pre-fill order price
+      const priceInput = document.getElementById('oe-price');
+      if (!priceInput.value || priceInput.value == '0') {
+        priceInput.value = t.bid.toFixed(2);
+      }
+    }
+  });
+  refreshBook();
+}
+
+let autoRunning = false;
+function autoFeed() {
+  const btn = document.getElementById('auto-btn');
+  if (autoRunning) {
+    clearInterval(autoFeedInterval);
+    autoRunning = false;
+    btn.textContent = 'AUTO';
+    btn.classList.remove('btn-sell');
+    btn.classList.add('btn-accent');
+  } else {
+    autoRunning = true;
+    btn.textContent = '■ STOP';
+    btn.classList.remove('btn-accent');
+    btn.classList.add('btn-sell');
+    autoFeedInterval = setInterval(() => feedStep(5), 200);
+  }
+}
+
+// ── Order Entry ───────────────────────────────────────────────────────────────
+function setOrderSide(side) {
+  orderSide = side;
+  const buyTab = document.getElementById('tab-buy');
+  const sellTab = document.getElementById('tab-sell');
+  const btn = document.getElementById('submit-btn');
+  if (side === 'BUY') {
+    buyTab.className = 'tab active-buy';
+    sellTab.className = 'tab';
+    btn.className = 'btn btn-buy';
+    btn.textContent = '▲ PLACE BUY ORDER';
+  } else {
+    buyTab.className = 'tab';
+    sellTab.className = 'tab active-sell';
+    btn.className = 'btn btn-sell';
+    btn.textContent = '▼ PLACE SELL ORDER';
+  }
+}
+
+function updateOrderForm() {
+  const type = document.getElementById('oe-type').value;
+  const priceGroup = document.getElementById('oe-price-group');
+  priceGroup.style.display = (type === 'MARKET') ? 'none' : 'block';
+}
+
+async function submitOrder() {
+  const sym = document.getElementById('oe-symbol').value;
+  const type = document.getElementById('oe-type').value;
+  const price = parseFloat(document.getElementById('oe-price').value) || 0;
+  const qty = parseInt(document.getElementById('oe-qty').value) || 100;
+  const cid = document.getElementById('oe-cid').value;
+
+  const body = {
+    symbol: sym, side: orderSide, type,
+    price, qty, client_id: cid,
+    market_price: price
+  };
+
+  const r = await api('POST', '/api/order', body);
+  if (!r) return;
+
+  if (r.approved) {
+    showToast(`✓ ${orderSide} ${qty} ${sym} @ ${type === 'MARKET' ? 'MKT' : '$'+price} — ${r.order.status}`, 'green');
+    if (r.trades && r.trades.length > 0) {
+      showToast(`⚡ ${r.trades.length} trade(s) executed!`, 'green');
+    }
+  } else {
+    showToast(`✗ REJECTED: ${r.reject_reason}`, 'red');
+    document.body.classList.add('flash-red');
+    setTimeout(() => document.body.classList.remove('flash-red'), 500);
+  }
+
+  refreshBook();
+  refreshPositions();
+  refreshTrades();
+}
+
+// ── Positions ─────────────────────────────────────────────────────────────────
+async function refreshPositions() {
+  const pos = await api('GET', '/api/positions');
+  if (!Array.isArray(pos)) return;
+
+  const tbody = document.getElementById('pos-body');
+  tbody.innerHTML = pos.filter(p => p.net_qty !== 0).map(p => {
+    const rPnl = p.realized_pnl || 0;
+    const uPnl = p.unrealized_pnl || 0;
+    const posDir = p.net_qty > 0 ? '+' : '';
+    return `<tr>
+      <td style="color:var(--cyan);font-weight:700">${p.symbol}</td>
+      <td style="color:${p.net_qty>0?'var(--green)':'var(--red)'}">${posDir}${fmtNum(p.net_qty)}</td>
+      <td>$${p.avg_price.toFixed(2)}</td>
+      <td style="color:${rPnl>=0?'var(--green)':'var(--red)'}">${rPnl>=0?'+':''}$${rPnl.toFixed(2)}</td>
+      <td style="color:${uPnl>=0?'var(--green)':'var(--red)'}">${uPnl>=0?'+':''}$${uPnl.toFixed(2)}</td>
+    </tr>`;
+  }).join('') || '<tr><td colspan="5" style="text-align:center;color:var(--dim);padding:10px">No open positions</td></tr>';
+
+  // Order log
+  const orders = await api('GET', '/api/orders');
+  if (!Array.isArray(orders)) return;
+  const logEl = document.getElementById('order-log');
+  logEl.innerHTML = orders.slice(-20).reverse().map(o => {
+    const isRej = o.status === 'REJECTED';
+    return `<div class="trade-entry" style="${isRej?'border-left:2px solid var(--red)':''}">
+      <span class="trade-side ${o.side==='BUY'?'buy-badge':'sell-badge'}">${o.side}</span>
+      <span style="color:var(--cyan)">${o.symbol}</span>
+      <span style="color:var(--dim)">${o.type}</span>
+      <span>$${(o.price||0).toFixed(2)}</span>
+      <span style="color:var(--dim)">×${fmtNum(o.qty)}</span>
+      <span style="color:${isRej?'var(--red)':o.status==='FILLED'?'var(--green)':'var(--dim)'}">
+        ${o.status}
+      </span>
+    </div>`;
+  }).join('');
+}
+
+// ── Trades ────────────────────────────────────────────────────────────────────
+async function refreshTrades() {
+  const trades = await api('GET', '/api/trades');
+  if (!Array.isArray(trades)) return;
+
+  document.getElementById('trade-count').textContent = `${trades.length} trades`;
+  document.getElementById('h-trades').textContent = trades.length;
+
+  const logEl = document.getElementById('trade-log');
+  logEl.innerHTML = trades.slice().reverse().slice(0, 100).map(t => {
+    const time = new Date(t.timestamp / 1e6).toISOString().substr(11,12);
+    return `<div class="trade-entry" style="padding:5px 12px">
+      <span style="color:var(--dim);font-size:9px">${time}</span>
+      <span style="color:var(--cyan);font-weight:700">${t.symbol}</span>
+      <span style="color:var(--text)">$${t.price.toFixed(4)}</span>
+      <span style="color:var(--dim)">×</span>
+      <span style="font-weight:600">${fmtNum(t.qty)}</span>
+      <span style="color:var(--dim);font-size:9px">#${t.trade_id}</span>
+    </div>`;
+  }).join('');
+}
+
+// ── Backtest ──────────────────────────────────────────────────────────────────
+async function runBacktest() {
+  const btn = document.getElementById('bt-btn');
+  btn.textContent = '⟳ RUNNING...'; btn.disabled = true;
+
+  try {
+    const r = await api('POST', '/api/backtest', {
+      strategy: document.getElementById('bt-strategy').value,
+      symbol:   document.getElementById('bt-symbol').value,
+      ticks:    parseInt(document.getElementById('bt-ticks').value),
+      start_price: parseFloat(document.getElementById('bt-price').value)
+    });
+
+    document.getElementById('bt-result').style.display = 'block';
+    setVal('bt-r-strategy', r.strategy);
+    setVal('bt-r-ticks',    fmtNum(r.ticks_processed));
+    setVal('bt-r-orders',   fmtNum(r.orders_submitted));
+    setVal('bt-r-fills',    fmtNum(r.orders_filled));
+    setVal('bt-r-rej',      fmtNum(r.orders_rejected));
+    setVal('bt-r-trades',   fmtNum(r.trades_count));
+
+    const pnlEl = document.getElementById('bt-r-pnl');
+    pnlEl.textContent = (r.total_pnl >= 0 ? '+' : '') + '$' + r.total_pnl.toFixed(2);
+    pnlEl.className = 'stat-val ' + (r.total_pnl >= 0 ? 'green' : 'red');
+
+    document.getElementById('bt-r-dd').textContent = '-$' + r.max_drawdown.toFixed(2);
+    document.getElementById('bt-r-sharpe').textContent = r.sharpe.toFixed(3);
+    document.getElementById('bt-r-p50').textContent = r.order_p50_us.toFixed(2) + 'µs';
+    document.getElementById('bt-r-p99').textContent = r.order_p99_us.toFixed(2) + 'µs';
+    document.getElementById('bt-r-thru').textContent = fmtNum(Math.round(r.throughput_eps)) + ' ev/s';
+
+    drawEquityCurve(r.equity_curve || []);
+  } finally {
+    btn.textContent = '▶ RUN BACKTEST'; btn.disabled = false;
+  }
+}
+
+function drawEquityCurve(curve) {
+  const canvas = document.getElementById('equity-canvas');
+  const ctx = canvas.getContext('2d');
+  const W = canvas.parentElement.offsetWidth - 2;
+  const H = 100;
+  canvas.width = W; canvas.height = H;
+
+  ctx.fillStyle = '#0d1219';
+  ctx.fillRect(0,0,W,H);
+
+  if (curve.length < 2) { return; }
+
+  const minV = Math.min(...curve);
+  const maxV = Math.max(...curve);
+  const range = maxV - minV || 1;
+  const pad = 15;
+
+  const xOf = i => pad + (i / (curve.length-1)) * (W - 2*pad);
+  const yOf = v => pad + (1 - (v - minV)/range) * (H - 2*pad);
+
+  // Zero line
+  const zy = yOf(0);
+  if (zy > pad && zy < H-pad) {
+    ctx.strokeStyle = '#1e2d3d';
+    ctx.setLineDash([3,3]);
+    ctx.beginPath(); ctx.moveTo(pad, zy); ctx.lineTo(W-pad, zy); ctx.stroke();
+    ctx.setLineDash([]);
+  }
+
+  ctx.beginPath();
+  ctx.moveTo(xOf(0), yOf(curve[0]));
+  for (let i = 1; i < curve.length; i++) ctx.lineTo(xOf(i), yOf(curve[i]));
+  ctx.strokeStyle = curve[curve.length-1] >= 0 ? '#00e676' : '#ff1744';
+  ctx.lineWidth = 1.5;
+  ctx.stroke();
+
+  ctx.fillStyle = '#5a7a90'; ctx.font = '8px JetBrains Mono';
+  ctx.textAlign = 'right';
+  ctx.fillText('$'+maxV.toFixed(1), W-2, pad+8);
+  ctx.fillText('$'+minV.toFixed(1), W-2, H-pad);
+}
+
+// ── Risk Limits ───────────────────────────────────────────────────────────────
+async function setRiskLimits() {
+  const r = await api('POST', '/api/risk/limits', {
+    max_order_qty:     parseInt(document.getElementById('r-max-qty').value),
+    max_position:      parseInt(document.getElementById('r-max-pos').value),
+    max_notional_usd:  parseFloat(document.getElementById('r-max-notional').value),
+    max_orders_per_sec: parseInt(document.getElementById('r-max-rate').value),
+  });
+  showToast(r.ok ? '✓ Risk limits updated' : '✗ Failed', r.ok ? 'green' : 'red');
+}
+
+// ── Reset ─────────────────────────────────────────────────────────────────────
+async function resetSim() {
+  await api('POST', '/api/reset');
+  priceHistory = {};
+  document.getElementById('trade-log').innerHTML = '';
+  showToast('↺ Simulator reset', 'cyan');
+}
+
+// ── Right mode ────────────────────────────────────────────────────────────────
+function setRightMode(mode) {
+  rightMode = mode;
+  ['positions','backtest','risk'].forEach(m => {
+    document.getElementById('view-'+m).style.display = (m === mode) ? 'flex' : 'none';
+  });
+  document.querySelectorAll('.mode-tab').forEach((t,i) => {
+    const modes = ['positions','backtest','risk'];
+    t.className = 'mode-tab' + (modes[i]===mode ? ' active' : '');
+  });
+}
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+function fmtNum(n) {
+  if (n >= 1e6) return (n/1e6).toFixed(1)+'M';
+  if (n >= 1e3) return (n/1e3).toFixed(1)+'K';
+  return n.toString();
+}
+
+function showToast(msg, color='cyan') {
+  const t = document.createElement('div');
+  t.className = 'toast';
+  t.style.borderColor = `var(--${color})`;
+  t.style.color = `var(--${color})`;
+  t.textContent = msg;
+  document.body.appendChild(t);
+  setTimeout(() => t.remove(), 3000);
+}
+
+// Resize handler for chart
+window.addEventListener('resize', () => {
+  if (priceHistory[selectedSymbol]) drawPriceChart();
+});
+</script>
+</body>
+</html>

src/core/order_book.cpp

@@ -0,0 +1,240 @@
+#include "core/order_book.hpp"
+#include <stdexcept>
+#include <cassert>
+
+namespace hft {
+
+OrderBook::OrderBook(std::string symbol) : symbol_(std::move(symbol)) {}
+
+void OrderBook::notify_order(const Order& o) {
+    if (order_cb_) order_cb_(o);
+}
+
+Trade OrderBook::make_trade(Order& buy, Order& sell, Price px, Quantity qty) {
+    Trade t;
+    t.trade_id      = next_trade_id_++;
+    t.buy_order_id  = buy.id;
+    t.sell_order_id = sell.id;
+    t.symbol        = symbol_;
+    t.price         = px;
+    t.qty           = qty;
+    t.timestamp     = now_ns();
+
+    buy.filled_qty  += qty;
+    sell.filled_qty += qty;
+    buy.status  = (buy.remaining()  == 0) ? OrderStatus::FILLED : OrderStatus::PARTIALLY_FILLED;
+    sell.status = (sell.remaining() == 0) ? OrderStatus::FILLED : OrderStatus::PARTIALLY_FILLED;
+    return t;
+}
+
+void OrderBook::add_to_book(Order& order) {
+    auto& book  = (order.side == Side::BUY) ? bids_ : asks_;
+    auto& level = book[order.price];
+    level.price = order.price;
+    level.orders.push_back(&order);
+    level.total_qty += order.remaining();
+    orders_[order.id] = &order;
+}
+
+void OrderBook::remove_from_book(Order& order) {
+    auto& book = (order.side == Side::BUY) ? bids_ : asks_;
+    auto it = book.find(order.price);
+    if (it == book.end()) return;
+
+    auto& level = it->second;
+    Quantity removed = 0;
+    level.orders.remove_if([&](Order* o) {
+        if (o->id == order.id) {
+            removed = o->remaining();
+            return true;
+        }
+        return false;
+    });
+    level.total_qty -= removed;
+    if (level.empty()) book.erase(it);
+    orders_.erase(order.id);
+}
+
+std::vector<Trade> OrderBook::try_match(Order& incoming, bool fok_check) {
+    std::vector<Trade> trades;
+
+    if (fok_check) {
+        Quantity available = 0;
+        if (incoming.side == Side::BUY) {
+            for (auto& [px, lvl] : asks_) {
+                if (incoming.type != OrderType::MARKET && px > incoming.price) break;
+                available += lvl.total_qty;
+                if (available >= incoming.qty) break;
+            }
+        } else {
+            for (auto rit = bids_.rbegin(); rit != bids_.rend(); ++rit) {
+                if (incoming.type != OrderType::MARKET && rit->first < incoming.price) break;
+                available += rit->second.total_qty;
+                if (available >= incoming.qty) break;
+            }
+        }
+        if (available < incoming.qty) {
+            incoming.status = OrderStatus::EXPIRED;
+            notify_order(incoming);
+            return trades;
+        }
+    }
+
+    if (incoming.side == Side::BUY) {
+        for (auto it = asks_.begin(); it != asks_.end() && incoming.remaining() > 0; ) {
+            auto& [px, level] = *it;
+            if (incoming.type == OrderType::LIMIT || incoming.type == OrderType::IOC) {
+                if (px > incoming.price) break;
+            }
+            while (!level.orders.empty() && incoming.remaining() > 0) {
+                Order* resting   = level.orders.front();
+                Quantity fill_qty = std::min(incoming.remaining(), resting->remaining());
+                Price    fill_px  = resting->price;
+
+                auto trade = make_trade(incoming, *resting, fill_px, fill_qty);
+                trades.push_back(trade);
+                if (trade_cb_) trade_cb_(trade);
+
+                level.total_qty -= fill_qty;
+                notify_order(*resting);
+                notify_order(incoming);
+
+                if (resting->is_done()) {
+                    level.orders.pop_front();
+                    orders_.erase(resting->id);
+                }
+            }
+            if (level.empty()) {
+                it = asks_.erase(it);
+            } else {
+                ++it;
+            }
+        }
+    } else {
+        // Sell-side: match against bids (highest first = rbegin)
+        // We iterate from the back using a reverse approach but erase safely.
+        while (!bids_.empty() && incoming.remaining() > 0) {
+            auto it = std::prev(bids_.end()); // best bid = last element
+            auto& [px, level] = *it;
+            if (incoming.type == OrderType::LIMIT || incoming.type == OrderType::IOC) {
+                if (px < incoming.price) break;
+            }
+            while (!level.orders.empty() && incoming.remaining() > 0) {
+                Order* resting   = level.orders.front();
+                Quantity fill_qty = std::min(incoming.remaining(), resting->remaining());
+                Price    fill_px  = resting->price;
+
+                auto trade = make_trade(*resting, incoming, fill_px, fill_qty);
+                trades.push_back(trade);
+                if (trade_cb_) trade_cb_(trade);
+
+                level.total_qty -= fill_qty;
+                notify_order(*resting);
+                notify_order(incoming);
+
+                if (resting->is_done()) {
+                    level.orders.pop_front();
+                    orders_.erase(resting->id);
+                }
+            }
+            if (level.empty()) {
+                bids_.erase(it);
+            } else {
+                break; // Remaining qty at this level, stop matching
+            }
+        }
+    }
+
+    return trades;
+}
+
+std::vector<Trade> OrderBook::add_order(Order& order) {
+    std::vector<Trade> trades;
+    order.status = OrderStatus::NEW;
+    notify_order(order);
+
+    switch (order.type) {
+        case OrderType::LIMIT: {
+            trades = try_match(order);
+            if (!order.is_done()) add_to_book(order);
+            break;
+        }
+        case OrderType::MARKET: {
+            trades = try_match(order);
+            if (order.remaining() > 0) {
+                order.status = OrderStatus::CANCELLED;
+                notify_order(order);
+            }
+            break;
+        }
+        case OrderType::IOC: {
+            trades = try_match(order);
+            if (order.remaining() > 0 && !order.is_done()) {
+                order.status = OrderStatus::EXPIRED;
+                notify_order(order);
+            }
+            break;
+        }
+        case OrderType::FOK: {
+            trades = try_match(order, true);
+            break;
+        }
+    }
+    return trades;
+}
+
+bool OrderBook::cancel_order(OrderId id) {
+    auto it = orders_.find(id);
+    if (it == orders_.end()) return false;
+    Order* o = it->second;
+    remove_from_book(*o);
+    o->status = OrderStatus::CANCELLED;
+    notify_order(*o);
+    return true;
+}
+
+bool OrderBook::modify_order(OrderId id, Price new_price, Quantity new_qty) {
+    auto it = orders_.find(id);
+    if (it == orders_.end()) return false;
+    Order* o = it->second;
+    if (new_qty <= o->filled_qty) return false;
+    remove_from_book(*o);
+    o->price = new_price;
+    o->qty   = new_qty;
+    add_to_book(*o);
+    return true;
+}
+
+std::optional<Order*> OrderBook::find_order(OrderId id) {
+    auto it = orders_.find(id);
+    if (it == orders_.end()) return std::nullopt;
+    return it->second;
+}
+
+OrderBookSnapshot OrderBook::snapshot(int depth) const {
+    OrderBookSnapshot snap;
+    snap.symbol    = symbol_;
+    snap.timestamp = now_ns();
+
+    int cnt = 0;
+    for (auto it = bids_.rbegin(); it != bids_.rend() && cnt < depth; ++it, ++cnt) {
+        L2Level l;
+        l.price       = it->first;
+        l.qty         = it->second.total_qty;
+        l.order_count = (int)it->second.orders.size();
+        snap.bids.push_back(l);
+    }
+
+    cnt = 0;
+    for (auto it = asks_.begin(); it != asks_.end() && cnt < depth; ++it, ++cnt) {
+        L2Level l;
+        l.price       = it->first;
+        l.qty         = it->second.total_qty;
+        l.order_count = (int)it->second.orders.size();
+        snap.asks.push_back(l);
+    }
+
+    return snap;
+}
+
+} // namespace hft

src/core/order_book.hpp

@@ -0,0 +1,73 @@
+#pragma once
+#include "types.hpp"
+#include <map>
+#include <unordered_map>
+#include <list>
+#include <functional>
+#include <vector>
+#include <optional>
+#include <algorithm>
+
+namespace hft {
+
+// Price level: all orders at same price, FIFO queue
+struct PriceLevel {
+    Price price;
+    std::list<Order*> orders;
+    Quantity total_qty = 0;
+
+    void add(Order* o) {
+        orders.push_back(o);
+        total_qty += o->remaining();
+    }
+    bool empty() const { return orders.empty(); }
+};
+
+using TradeCallback  = std::function<void(const Trade&)>;
+using OrderCallback  = std::function<void(const Order&)>;
+
+class OrderBook {
+public:
+    explicit OrderBook(std::string symbol);
+
+    // Returns trades generated
+    std::vector<Trade> add_order(Order& order);
+    bool cancel_order(OrderId id);
+    bool modify_order(OrderId id, Price new_price, Quantity new_qty);
+
+    OrderBookSnapshot snapshot(int depth = 10) const;
+    std::optional<Order*> find_order(OrderId id);
+
+    void set_trade_callback(TradeCallback cb) { trade_cb_ = std::move(cb); }
+    void set_order_callback(OrderCallback cb) { order_cb_ = std::move(cb); }
+
+    size_t order_count()  const { return orders_.size(); }
+    size_t bid_levels()   const { return bids_.size(); }
+    size_t ask_levels()   const { return asks_.size(); }
+    Price  best_bid()     const { return bids_.empty() ? 0 : bids_.rbegin()->first; }
+    Price  best_ask()     const { return asks_.empty() ? 0 : asks_.begin()->first; }
+    const std::string& symbol() const { return symbol_; }
+
+private:
+    std::string symbol_;
+    uint64_t    next_trade_id_ = 1;
+
+    // bids: descending (highest first) → map with reverse
+    std::map<Price, PriceLevel> bids_;  // sorted asc, iterate rbegin for best
+    std::map<Price, PriceLevel> asks_;  // sorted asc, begin = best ask
+
+    std::unordered_map<OrderId, Order*> orders_;
+
+    TradeCallback trade_cb_;
+    OrderCallback order_cb_;
+
+    std::vector<Trade> match_limit(Order& incoming);
+    std::vector<Trade> match_market(Order& incoming);
+    std::vector<Trade> try_match(Order& incoming, bool fok_check = false);
+    Trade make_trade(Order& buy, Order& sell, Price px, Quantity qty);
+    void  add_to_book(Order& order);
+    void  remove_from_book(Order& order);
+    void  notify_order(const Order& o);
+};
+
+} // namespace hft

src/core/simulator.cpp

@@ -0,0 +1,252 @@
+#include "core/simulator.hpp"
+#include <algorithm>
+#include <numeric>
+#include <cmath>
+#include <unordered_set>
+
+namespace hft {
+
+ExchangeSimulator::ExchangeSimulator(RiskLimits limits)
+    : risk_(limits), journal_("session.journal") {}
+
+void ExchangeSimulator::add_symbol(const std::string& symbol) {
+    std::lock_guard<std::mutex> lock(mtx_);
+    if (books_.count(symbol)) return;
+    auto book = std::make_unique<OrderBook>(symbol);
+    book->set_trade_callback([this](const Trade& t) {
+        total_trades_.fetch_add(1, std::memory_order_relaxed);
+        if (trade_cb_) trade_cb_(t);
+    });
+    book->set_order_callback([this](const Order& o) {
+        if (order_cb_) order_cb_(o);
+    });
+    books_[symbol] = std::move(book);
+}
+
+// Fix: Now takes const Order& and safely clones it to guarantee memory persistence
+ExchangeSimulator::SubmitResult ExchangeSimulator::submit_order(const Order& order_in, double market_price) {
+    int64_t t0 = now_ns();
+    total_orders_.fetch_add(1, std::memory_order_relaxed);
+
+    auto risk_result = risk_.check_order(order_in, market_price);
+    if (!risk_result.approved) {
+        total_rejects_.fetch_add(1, std::memory_order_relaxed);
+        return {false, risk_result.message, {}};
+    }
+
+    std::lock_guard<std::mutex> lock(mtx_);
+    auto it = books_.find(order_in.symbol);
+    if (it == books_.end()) {
+        total_rejects_.fetch_add(1, std::memory_order_relaxed);
+        return {false, "Unknown symbol: " + order_in.symbol, {}};
+    }
+
+    // Fix: Allocate order uniquely so OrderBook holds a stable, valid pointer
+    auto order_ptr = std::make_unique<Order>(order_in);
+    order_ptr->timestamp = now_ns();
+    Order& order = *order_ptr;
+    order_store_[order.id] = std::move(order_ptr);
+
+    auto trades = it->second->add_order(order);
+
+    for (auto& t : trades) {
+        Side fill_side = (t.buy_order_id == order.id) ? Side::BUY : Side::SELL;
+        risk_.on_fill(t.symbol, fill_side, t.qty, from_price(t.price));
+    }
+
+    // Fix: Recorded inside the mutex scope to prevent vector corruption
+    order_lat_.record(now_ns() - t0);
+
+    return {true, "OK", trades};
+}
+
+bool ExchangeSimulator::cancel_order(const std::string& symbol, OrderId id) {
+    std::lock_guard<std::mutex> lock(mtx_);
+    auto it = books_.find(symbol);
+    if (it == books_.end()) return false;
+    return it->second->cancel_order(id);
+}
+
+bool ExchangeSimulator::modify_order(const std::string& symbol, OrderId id,
+                                      Price new_price, Quantity new_qty) {
+    std::lock_guard<std::mutex> lock(mtx_);
+    auto it = books_.find(symbol);
+    if (it == books_.end()) return false;
+    return it->second->modify_order(id, new_price, new_qty);
+}
+
+void ExchangeSimulator::on_tick(const MarketDataTick& tick) {
+    int64_t t0 = now_ns();
+    std::lock_guard<std::mutex> lock(mtx_);
+    risk_.update_market_price(tick.symbol, from_price(tick.last_price));
+    tick_lat_.record(now_ns() - t0);
+}
+
+OrderBookSnapshot ExchangeSimulator::get_snapshot(const std::string& symbol, int depth) const {
+    std::lock_guard<std::mutex> lock(mtx_);
+    auto it = books_.find(symbol);
+    if (it == books_.end()) return {};
+    return it->second->snapshot(depth);
+}
+
+std::vector<std::string> ExchangeSimulator::symbols() const {
+    std::lock_guard<std::mutex> lock(mtx_);
+    std::vector<std::string> s;
+    for (auto& [k, _] : books_) s.push_back(k);
+    return s;
+}
+
+Position ExchangeSimulator::get_position(const std::string& symbol) const {
+    return risk_.get_position(symbol);
+}
+
+std::unordered_map<std::string, Position> ExchangeSimulator::all_positions() const {
+    return risk_.all_positions();
+}
+
+double ExchangeSimulator::total_pnl() const {
+    return risk_.total_pnl();
+}
+
+Backtester::Backtester(RiskLimits limits) : limits_(limits) {}
+
+void Backtester::set_strategy(std::unique_ptr<IStrategy> strategy) {
+    strategy_ = std::move(strategy);
+}
+
+void Backtester::add_symbol(const std::string& symbol) {
+    symbols_.push_back(symbol);
+}
+
+void Backtester::process_signals(const std::vector<StrategySignal>& sigs,
+                                  const MarketDataTick& tick,
+                                  BacktestResult& result,
+                                  std::unordered_map<OrderId, Order>& live_orders) {
+    for (auto& sig : sigs) {
+        if (sig.action == StrategySignal::Action::NONE) continue;
+
+        if (sig.action == StrategySignal::Action::CANCEL) {
+            sim_->cancel_order(tick.symbol, sig.cancel_id);
+            live_orders.erase(sig.cancel_id);
+            continue;
+        }
+        if (sig.action == StrategySignal::Action::CANCEL_ALL) {
+            for (auto& [id, ord] : live_orders)
+                sim_->cancel_order(ord.symbol, id);
+            live_orders.clear();
+            continue;
+        }
+
+        Order order;
+        order.id        = sim_->next_order_id();
+        order.symbol    = sig.symbol.empty() ? tick.symbol : sig.symbol;
+        order.side      = (sig.action == StrategySignal::Action::BUY) ? Side::BUY : Side::SELL;
+        order.type      = sig.type;
+        order.price     = sig.price;
+        order.qty       = sig.qty;
+        order.client_id = sig.reason;
+
+        ++result.orders_submitted;
+        auto res = sim_->submit_order(order, from_price(tick.last_price));
+
+        if (!res.approved) {
+            ++result.orders_rejected;
+        } else {
+            if (!order.is_done()) live_orders[order.id] = order;
+            for (auto& t : res.trades) {
+                ++result.orders_filled;
+                ++result.trades_count;
+                result.trades.push_back(t);
+                strategy_->on_trade(t);
+            }
+            strategy_->on_order_update(order);
+        }
+    }
+}
+
+BacktestResult Backtester::run(const std::vector<MarketDataTick>& ticks,
+                                bool enable_journal,
+                                const std::string& journal_path) {
+    BacktestResult result;
+    if (!strategy_ || ticks.empty()) return result;
+    result.strategy_name = strategy_->name();
+
+    sim_ = std::make_unique<ExchangeSimulator>(limits_);
+    for (auto& sym : symbols_) sim_->add_symbol(sym);
+    if (symbols_.empty() && !ticks.empty()) {
+        std::unordered_map<std::string, bool> seen;
+        for (auto& t : ticks) {
+            if (!seen[t.symbol]) {
+                sim_->add_symbol(t.symbol);
+                seen[t.symbol] = true;
+            }
+        }
+    }
+
+    std::unordered_set<std::string> inited;
+    for (auto& tick : ticks) {
+        if (!inited.count(tick.symbol)) {
+            strategy_->on_init(tick.symbol);
+            inited.insert(tick.symbol);
+        }
+    }
+
+    std::unordered_map<OrderId, Order> live_orders;
+    double peak_equity = std::numeric_limits<double>::lowest();
+    int64_t ts_start   = now_ns();
+
+    for (auto& tick : ticks) {
+        int64_t t0 = now_ns();
+        sim_->on_tick(tick);
+
+        auto snap = sim_->get_snapshot(tick.symbol);
+        auto sigs = strategy_->on_tick(tick, snap);
+
+        process_signals(sigs, tick, result, live_orders);
+
+        if (result.ticks_processed % 100 == 0) {
+            double equity = sim_->total_pnl();
+            result.equity_curve.push_back(equity);
+            if (equity > peak_equity) peak_equity = equity;
+            if (peak_equity > std::numeric_limits<double>::lowest()) {
+                double drawdown = peak_equity - equity;
+                if (drawdown > result.max_drawdown) result.max_drawdown = drawdown;
+            }
+        }
+
+        result.tick_latency.record(now_ns() - t0);
+        ++result.ticks_processed;
+    }
+
+    int64_t elapsed_ns  = now_ns() - ts_start;
+    result.total_pnl    = sim_->total_pnl();
+
+    auto pos = sim_->all_positions();
+    for (auto& [sym, p] : pos) {
+        result.realized_pnl   += p.realized_pnl;
+        result.unrealized_pnl += p.unrealized_pnl;
+    }
+
+    result.order_latency = sim_->order_latency();
+    result.order_latency.compute_percentiles();
+    result.tick_latency.compute_percentiles();
+
+    double elapsed_s       = elapsed_ns / 1e9;
+    result.throughput_eps  = elapsed_s > 0 ? result.ticks_processed / elapsed_s : 0;
+
+    if (result.equity_curve.size() > 2) {
+        std::vector<double> returns;
+        returns.reserve(result.equity_curve.size() - 1);
+        for (size_t i = 1; i < result.equity_curve.size(); ++i)
+            returns.push_back(result.equity_curve[i] - result.equity_curve[i - 1]);
+        double mean = std::accumulate(returns.begin(), returns.end(), 0.0) / returns.size();
+        double var  = 0;
+        for (double r : returns) var += (r - mean) * (r - mean);
+        double std_dev = std::sqrt(var / returns.size());
+        result.sharpe = (std_dev > 1e-9) ? (mean / std_dev * std::sqrt(252.0)) : 0;
+    }
+
+    return result;
+}
+
+} // namespace hft

src/core/simulator.hpp

@@ -0,0 +1,118 @@
+#pragma once
+#include "core/types.hpp"
+#include "core/order_book.hpp"
+#include "risk/risk_manager.hpp"
+#include "journal/journal.hpp"
+#include "strategy/strategy.hpp"
+#include <unordered_map>
+#include <atomic>
+#include <memory>
+#include <mutex>
+#include <deque>
+#include <functional>
+
+namespace hft {
+
+struct BacktestResult {
+    std::string strategy_name;
+    int64_t     ticks_processed    = 0;
+    int64_t     orders_submitted   = 0;
+    int64_t     orders_filled      = 0;
+    int64_t     orders_rejected    = 0;
+    int64_t     trades_count       = 0;
+    double      total_pnl          = 0;
+    double      realized_pnl       = 0;
+    double      unrealized_pnl     = 0;
+    double      max_drawdown       = 0;
+    double      sharpe             = 0;
+    LatencyStats order_latency;
+    LatencyStats tick_latency;
+    double      throughput_eps     = 0; 
+    std::vector<double> equity_curve;
+    std::vector<Trade>  trades;
+};
+
+class ExchangeSimulator {
+public:
+    explicit ExchangeSimulator(RiskLimits limits = {});
+
+    void add_symbol(const std::string& symbol);
+
+    struct SubmitResult {
+        bool   approved;
+        std::string reject_reason;
+        std::vector<Trade> trades;
+    };
+    
+    // Fix: Takes const reference to avoid scope expiration
+    SubmitResult submit_order(const Order& order, double market_price = 0.0);
+    
+    bool cancel_order(const std::string& symbol, OrderId id);
+    bool modify_order(const std::string& symbol, OrderId id, Price new_price, Quantity new_qty);
+    void on_tick(const MarketDataTick& tick);
+
+    OrderBookSnapshot get_snapshot(const std::string& symbol, int depth = 10) const;
+    std::vector<std::string> symbols() const;
+
+    Position get_position(const std::string& symbol) const;
+    std::unordered_map<std::string, Position> all_positions() const;
+    double total_pnl() const;
+    RiskManager& risk() { return risk_; }
+
+    void set_trade_callback(TradeCallback cb)  { trade_cb_ = std::move(cb); }
+    void set_order_callback(OrderCallback cb)  { order_cb_ = std::move(cb); }
+
+    LatencyStats& order_latency() { return order_lat_; }
+    LatencyStats& tick_latency()  { return tick_lat_; }
+    int64_t total_orders()  const { return total_orders_.load(std::memory_order_relaxed); }
+    int64_t total_trades()  const { return total_trades_.load(std::memory_order_relaxed); }
+    int64_t total_rejects() const { return total_rejects_.load(std::memory_order_relaxed); }
+
+    OrderId next_order_id() { return ++next_oid_; }
+
+private:
+    std::unordered_map<std::string, std::unique_ptr<OrderBook>> books_;
+    // Fix: Correct key type and properly controls memory lifetime
+    std::unordered_map<OrderId, std::unique_ptr<Order>> order_store_; 
+    RiskManager risk_;
+    BinaryJournal journal_;
+    mutable std::mutex mtx_;
+
+    TradeCallback trade_cb_;
+    OrderCallback order_cb_;
+
+    std::atomic<OrderId> next_oid_{1000};
+    LatencyStats order_lat_, tick_lat_;
+    
+    // Fix: Atomic counters for thread-safe operations in main.cpp
+    std::atomic<int64_t> total_orders_{0};
+    std::atomic<int64_t> total_trades_{0};
+    std::atomic<int64_t> total_rejects_{0};
+};
+
+class Backtester {
+public:
+    explicit Backtester(RiskLimits limits = {});
+
+    void set_strategy(std::unique_ptr<IStrategy> strategy);
+    void add_symbol(const std::string& symbol);
+
+    BacktestResult run(const std::vector<MarketDataTick>& ticks,
+                       bool enable_journal = true,
+                       const std::string& journal_path = "replay.journal");
+
+
+
+private:
+    std::unique_ptr<IStrategy>  strategy_;
+    std::unique_ptr<ExchangeSimulator> sim_;
+    RiskLimits limits_;
+    std::vector<std::string> symbols_;
+
+    void process_signals(const std::vector<StrategySignal>& sigs,
+                         const MarketDataTick& tick,
+                         BacktestResult& result,
+                         std::unordered_map<OrderId, Order>& live_orders);
+};
+
+} // namespace hft

src/core/types.hpp

@@ -0,0 +1,141 @@
+#pragma once
+#include <cstdint>
+#include <string>
+#include <chrono>
+#include <vector>
+#include <algorithm>
+#include <cmath>
+
+namespace hft {
+
+using Price     = int64_t;   // price in ticks (e.g. 1234567 = $123.4567)
+using Quantity  = int64_t;
+using OrderId   = uint64_t;
+using Timestamp = int64_t;   // nanoseconds since epoch
+
+constexpr Price PRICE_SCALE = 10000; // 4 decimal places
+
+inline Price to_price(double d) { return static_cast<Price>(std::llround(d * PRICE_SCALE)); }
+inline double from_price(Price p) { return static_cast<double>(p) / PRICE_SCALE; }
+
+enum class Side : uint8_t { BUY = 0, SELL = 1 };
+enum class OrderType : uint8_t { LIMIT = 0, MARKET = 1, IOC = 2, FOK = 3 };
+enum class OrderStatus : uint8_t {
+    PENDING, NEW, PARTIALLY_FILLED, FILLED, CANCELLED, REJECTED, EXPIRED
+};
+enum class TimeInForce : uint8_t { GTC = 0, IOC = 1, FOK = 2, DAY = 3 };
+
+struct Order {
+    OrderId    id         = 0;
+    std::string symbol;
+    Side       side       = Side::BUY;
+    OrderType  type       = OrderType::LIMIT;
+    Price      price      = 0;      
+    Quantity   qty        = 0;
+    Quantity   filled_qty = 0;
+    OrderStatus status    = OrderStatus::PENDING;
+    Timestamp  timestamp  = 0;
+    std::string client_id;
+
+    Quantity remaining() const { return qty - filled_qty; }
+    bool is_done() const {
+        return status == OrderStatus::FILLED ||
+               status == OrderStatus::CANCELLED ||
+               status == OrderStatus::REJECTED ||
+               status == OrderStatus::EXPIRED;
+    }
+};
+
+struct Trade {
+    uint64_t   trade_id;
+    OrderId    buy_order_id;
+    OrderId    sell_order_id;
+    std::string symbol;
+    Price      price;
+    Quantity   qty;
+    Timestamp  timestamp;
+};
+
+struct MarketDataTick {
+    Timestamp  timestamp;
+    std::string symbol;
+    Price      bid_price;
+    Quantity   bid_qty;
+    Price      ask_price;
+    Quantity   ask_qty;
+    Price      last_price;
+    Quantity   last_qty;
+};
+
+struct L2Level {
+    Price    price;
+    Quantity qty;
+    int      order_count;
+};
+
+struct OrderBookSnapshot {
+    std::string symbol;
+    Timestamp   timestamp;
+    std::vector<L2Level> bids; 
+    std::vector<L2Level> asks; 
+    Price best_bid() const { return bids.empty() ? 0 : bids[0].price; }
+    Price best_ask() const { return asks.empty() ? 0 : asks[0].price; }
+    Price mid()      const {
+        if (bids.empty() || asks.empty()) return 0;
+        return (best_bid() + best_ask()) / 2;
+    }
+    double spread()  const {
+        if (bids.empty() || asks.empty()) return 0.0;
+        Price s = best_ask() - best_bid();
+        return s > 0 ? from_price(s) : 0.0;
+    }
+};
+
+struct RiskLimits {
+    Quantity max_order_qty     = 10000;
+    Quantity max_position      = 100000;
+    double   max_notional_usd  = 1000000.0;
+    int      max_orders_per_sec = 1000;
+    bool     enabled           = true;
+};
+
+struct Position {
+    std::string symbol;
+    Quantity    net_qty   = 0;  
+    double      avg_price = 0.0;
+    double      realized_pnl  = 0.0;
+    double      unrealized_pnl = 0.0;
+    double      notional() const { return std::abs(net_qty * avg_price); }
+};
+
+struct LatencyStats {
+    int64_t count   = 0;
+    int64_t sum_ns  = 0;
+    int64_t min_ns  = INT64_MAX;
+    int64_t max_ns  = 0;
+    int64_t p50_ns  = 0;
+    int64_t p99_ns  = 0;
+    std::vector<int64_t> samples; 
+
+    void record(int64_t ns) {
+        ++count; sum_ns += ns;
+        if (ns < min_ns) min_ns = ns;
+        if (ns > max_ns) max_ns = ns;
+        samples.push_back(ns);
+    }
+    void compute_percentiles() {
+        if (samples.empty()) return;
+        std::vector<int64_t> sorted = samples; // Fix: Copy before sort
+        std::sort(sorted.begin(), sorted.end());
+        p50_ns = sorted[sorted.size() * 50 / 100];
+        p99_ns = sorted[sorted.size() * 99 / 100];
+    }
+    double avg_us() const { return count ? (double)sum_ns / count / 1000.0 : 0; }
+};
+
+inline Timestamp now_ns() {
+    return std::chrono::duration_cast<std::chrono::nanoseconds>(
+        std::chrono::high_resolution_clock::now().time_since_epoch()).count();
+}
+
+} // namespace hft

src/engine_cli.cpp

@@ -0,0 +1,313 @@
+#include "core/simulator.hpp"
+#include "core/types.hpp"
+#include "strategy/strategy.hpp"
+#include "network/serializer.hpp"
+
+#include <iostream>
+#include <string>
+#include <sstream>
+#include <unordered_map>
+#include <memory>
+#include <unordered_set>
+#include <fstream>
+
+using namespace hft;
+
+static std::string jget(const std::string& body, const std::string& key) {
+    auto pos = body.find("\"" + key + "\"");
+    if (pos == std::string::npos) return "";
+    pos = body.find(":", pos);
+    if (pos == std::string::npos) return "";
+    ++pos;
+    while (pos < body.size() && (body[pos] == ' ' || body[pos] == '\t')) ++pos;
+    if (pos >= body.size()) return "";
+    if (body[pos] == '"') {
+        ++pos;
+        size_t end = body.find('"', pos);
+        return body.substr(pos, end - pos);
+    }
+    size_t end = body.find_first_of(",}\n", pos);
+    return body.substr(pos, end - pos);
+}
+
+static RiskLimits g_limits;
+static std::unique_ptr<ExchangeSimulator> g_sim;
+static std::vector<MarketDataTick> g_tick_feed;
+static size_t g_feed_idx = 0;
+static std::deque<std::string> g_trade_log;
+static std::deque<std::string> g_order_log;
+
+static void init_sim() {
+    g_sim = std::make_unique<ExchangeSimulator>(g_limits);
+    for (auto& sym : {"AAPL", "GOOG", "MSFT", "TSLA", "NVDA"})
+        g_sim->add_symbol(sym);
+    g_sim->set_trade_callback([](const Trade& t) {
+        g_trade_log.push_back(trade_to_json(t));
+        if ((int)g_trade_log.size() > 500) g_trade_log.pop_front();
+    });
+    g_sim->set_order_callback([](const Order& o) {
+        g_order_log.push_back(order_to_json(o));
+        if ((int)g_order_log.size() > 500) g_order_log.pop_front();
+    });
+}
+
+static void init_feed() {
+    const char* syms[]  = {"AAPL", "GOOG", "MSFT", "TSLA", "NVDA"};
+    double prices[]     = {185.0, 140.0, 375.0, 245.0, 485.0};
+    g_tick_feed.clear();
+    for (int i = 0; i < 5; ++i) {
+        MarketDataParser::Config cfg;
+        cfg.symbol     = syms[i];
+        cfg.start_price = prices[i];
+        cfg.ticks      = 3000;
+        cfg.volatility = 0.0008;
+        cfg.spread_bps = 3.0;
+        cfg.seed       = 42 + i;
+        auto ticks = MarketDataParser::generate_synthetic(cfg);
+        for (auto& t : ticks) g_tick_feed.push_back(t);
+    }
+    std::sort(g_tick_feed.begin(), g_tick_feed.end(),
+        [](const MarketDataTick& a, const MarketDataTick& b) {
+            return a.timestamp < b.timestamp;
+        });
+    g_feed_idx = 0;
+}
+
+static std::string handle(const std::string& cmd, const std::string& payload) {
+
+    if (cmd == "status") {
+        g_sim->order_latency().compute_percentiles();
+        g_sim->tick_latency().compute_percentiles();
+        return "{\"total_orders\":"   + J::num(g_sim->total_orders()) +
+               ",\"total_trades\":"   + J::num(g_sim->total_trades()) +
+               ",\"total_rejects\":"  + J::num(g_sim->total_rejects()) +
+               ",\"total_pnl\":"      + J::num(g_sim->total_pnl()) +
+               ",\"order_p50_us\":"   + J::num(g_sim->order_latency().p50_ns / 1000.0) +
+               ",\"order_p99_us\":"   + J::num(g_sim->order_latency().p99_ns / 1000.0) +
+               ",\"tick_p50_us\":"    + J::num(g_sim->tick_latency().p50_ns  / 1000.0) +
+               ",\"tick_p99_us\":"    + J::num(g_sim->tick_latency().p99_ns  / 1000.0) +
+               ",\"risk_checked\":"   + J::num(g_sim->risk().orders_checked()) +
+               ",\"risk_rejected\":"  + J::num(g_sim->risk().orders_rejected()) +
+               ",\"feed_size\":"      + J::num((int64_t)g_tick_feed.size()) +
+               ",\"feed_idx\":"       + J::num((int64_t)g_feed_idx) + "}";
+    }
+
+    if (cmd == "reset") {
+        g_trade_log.clear();
+        g_order_log.clear();
+        init_sim();
+        init_feed();
+        return "{\"ok\":true}";
+    }
+
+    if (cmd == "book") {
+        std::string sym = jget(payload, "symbol");
+        if (sym.empty()) sym = "AAPL";
+        auto snap = g_sim->get_snapshot(sym);
+        return snapshot_to_json(snap);
+    }
+
+    if (cmd == "positions") {
+        auto pos = g_sim->all_positions();
+        std::string r = "[";
+        bool first = true;
+        for (auto& [sym, p] : pos) {
+            if (!first) r += ",";
+            r += position_to_json(p);
+            first = false;
+        }
+        return r + "]";
+    }
+
+    if (cmd == "trades") {
+        std::string r = "[";
+        bool first = true;
+        for (auto& t : g_trade_log) {
+            if (!first) r += ",";
+            r += t;
+            first = false;
+        }
+        return r + "]";
+    }
+
+    if (cmd == "orders") {
+        std::string r = "[";
+        bool first = true;
+        for (auto& o : g_order_log) {
+            if (!first) r += ",";
+            r += o;
+            first = false;
+        }
+        return r + "]";
+    }
+
+    if (cmd == "order") {
+        Order order;
+        order.id      = g_sim->next_order_id();
+        order.symbol  = jget(payload, "symbol");
+        if (order.symbol.empty()) order.symbol = "AAPL";
+        std::string side_s = jget(payload, "side");
+        order.side = (side_s == "SELL") ? Side::SELL : Side::BUY;
+        std::string type_s = jget(payload, "type");
+        if      (type_s == "MARKET") order.type = OrderType::MARKET;
+        else if (type_s == "IOC")    order.type = OrderType::IOC;
+        else if (type_s == "FOK")    order.type = OrderType::FOK;
+        else                          order.type = OrderType::LIMIT;
+        try {
+            order.price = to_price(std::stod(jget(payload, "price")));
+            order.qty   = std::stoll(jget(payload, "qty"));
+        } catch (...) {
+            return "{\"error\":\"invalid price or qty\"}";
+        }
+        order.client_id = jget(payload, "client_id");
+
+        double mkt_px = 0;
+        try { mkt_px = std::stod(jget(payload, "market_price")); } catch (...) {}
+
+        auto result = g_sim->submit_order(order, mkt_px);
+        std::string r = "{\"approved\":" + J::boolean(result.approved) +
+                        ",\"order\":"        + order_to_json(order) +
+                        ",\"reject_reason\":" + J::str(result.reject_reason) +
+                        ",\"trades\":[";
+        for (size_t i = 0; i < result.trades.size(); ++i) {
+            if (i) r += ",";
+            r += trade_to_json(result.trades[i]);
+        }
+        return r + "]}";
+    }
+
+    if (cmd == "cancel") {
+        OrderId id  = 0;
+        std::string sym = jget(payload, "symbol");
+        try { id = std::stoull(jget(payload, "id")); } catch (...) {}
+        bool ok = g_sim->cancel_order(sym, id);
+        return "{\"cancelled\":" + J::boolean(ok) + "}";
+    }
+
+    if (cmd == "feed_step") {
+        int n = 10;
+        std::string n_str = jget(payload, "n");
+        if (!n_str.empty()) {
+            try { n = std::stoi(n_str); } catch (...) {}
+        }
+        n = std::max(1, std::min(n, 200));
+
+        std::string r = "[";
+        bool first = true;
+        for (int i = 0; i < n; ++i) {
+            if (g_feed_idx >= g_tick_feed.size()) g_feed_idx = 0;
+            auto& tick = g_tick_feed[g_feed_idx++];
+            g_sim->on_tick(tick);
+            if (!first) r += ",";
+            r += "{\"symbol\":"  + J::str(tick.symbol) +
+                 ",\"bid\":"     + J::num(from_price(tick.bid_price)) +
+                 ",\"ask\":"     + J::num(from_price(tick.ask_price)) +
+                 ",\"last\":"    + J::num(from_price(tick.last_price)) +
+                 ",\"bid_qty\":" + J::num(tick.bid_qty) +
+                 ",\"ask_qty\":" + J::num(tick.ask_qty) +
+                 ",\"ts\":"      + J::num(tick.timestamp) + "}";
+            first = false;
+        }
+        return r + "]";
+    }
+
+    if (cmd == "backtest") {
+        std::string strategy_name = jget(payload, "strategy");
+        std::string symbol        = jget(payload, "symbol");
+        if (symbol.empty()) symbol = "AAPL";
+        int ticks = 5000;
+        double start_price = 150.0;
+        try { ticks       = std::stoi(jget(payload, "ticks")); }       catch (...) {}
+        try { start_price = std::stod(jget(payload, "start_price")); } catch (...) {}
+        ticks = std::min(std::max(ticks, 200), 50000);
+
+        MarketDataParser::Config cfg;
+        cfg.symbol      = symbol;
+        cfg.start_price = start_price;
+        cfg.ticks       = ticks;
+        cfg.volatility  = 0.001;
+        cfg.seed        = 777;
+        auto bt_ticks   = MarketDataParser::generate_synthetic(cfg);
+
+        RiskLimits rl;
+        rl.max_order_qty      = 10000;
+        rl.max_position       = 500000;
+        rl.max_notional_usd   = 1e9;
+        rl.max_orders_per_sec = 10000;
+
+        Backtester bt(rl);
+        bt.add_symbol(symbol);
+
+        std::unique_ptr<IStrategy> strat;
+        if (strategy_name == "Momentum")
+            strat = std::make_unique<MomentumStrategy>();
+        else if (strategy_name == "MeanReversion")
+            strat = std::make_unique<MeanReversionStrategy>();
+        else
+            strat = std::make_unique<MarketMakingStrategy>();
+        bt.set_strategy(std::move(strat));
+
+        auto result = bt.run(bt_ticks, false);
+        return backtest_result_to_json(result);
+    }
+
+    if (cmd == "risk_limits") {
+        try {
+            g_limits.max_order_qty      = std::stoll(jget(payload, "max_order_qty"));
+            g_limits.max_position       = std::stoll(jget(payload, "max_position"));
+            g_limits.max_notional_usd   = std::stod(jget(payload, "max_notional_usd"));
+            g_limits.max_orders_per_sec = std::stoi(jget(payload, "max_orders_per_sec"));
+            g_sim->risk().set_limits(g_limits);
+            return "{\"ok\":true}";
+        } catch (...) {
+            return "{\"error\":\"bad limits\"}";
+        }
+    }
+
+    if (cmd == "get_limits") {
+        auto l = g_sim->risk().get_limits();
+        return "{\"max_order_qty\":"     + J::num(l.max_order_qty) +
+               ",\"max_position\":"      + J::num(l.max_position) +
+               ",\"max_notional_usd\":"  + J::num(l.max_notional_usd, 0) +
+               ",\"max_orders_per_sec\":" + J::num((int64_t)l.max_orders_per_sec) +
+               ",\"enabled\":"           + J::boolean(l.enabled) + "}";
+    }
+
+    if (cmd == "symbols") {
+        auto syms = g_sim->symbols();
+        std::string r = "[";
+        for (size_t i = 0; i < syms.size(); ++i) {
+            if (i) r += ",";
+            r += J::str(syms[i]);
+        }
+        return r + "]";
+    }
+
+    return "{\"error\":" + J::str("unknown command: " + cmd) + "}";
+}
+
+int main() {
+    g_limits.max_order_qty      = 10000;
+    g_limits.max_position       = 500000;
+    g_limits.max_notional_usd   = 50000000.0;
+    g_limits.max_orders_per_sec = 2000;
+
+    init_sim();
+    init_feed();
+
+    std::string line;
+    while (std::getline(std::cin, line)) {
+        if (line.empty()) continue;
+        size_t sp          = line.find(' ');
+        std::string cmd    = (sp == std::string::npos) ? line : line.substr(0, sp);
+        std::string payload = (sp == std::string::npos) ? "{}" : line.substr(sp + 1);
+        try {
+            std::cout << handle(cmd, payload) << "\n";
+            std::cout.flush();
+        } catch (const std::exception& e) {
+            std::cout << "{\"error\":" << J::str(e.what()) << "}\n";
+            std::cout.flush();
+        }
+    }
+    return 0;
+}

src/journal/journal.cpp

@@ -0,0 +1,204 @@
+#include "journal/journal.hpp"
+#include <cmath>
+#include <random>
+#include <stdexcept>
+#include <sstream>
+#include <fstream>
+
+namespace hft {
+
+BinaryJournal::BinaryJournal(const std::string& path) : path_(path) {}
+
+BinaryJournal::~BinaryJournal() { close(); }
+
+bool BinaryJournal::open_write() {
+    wfile_.open(path_, std::ios::binary | std::ios::trunc);
+    if (!wfile_.good()) return false;
+    // Write magic header
+    const char magic[] = "HFTJ\x01\x00";
+    wfile_.write(magic, 6);
+    return true;
+}
+
+bool BinaryJournal::open_read() {
+    rfile_.open(path_, std::ios::binary);
+    if (!rfile_.good()) return false;
+    char magic[6];
+    rfile_.read(magic, 6);
+    return true;
+}
+
+void BinaryJournal::close() {
+    if (wfile_.is_open()) wfile_.close();
+    if (rfile_.is_open()) rfile_.close();
+}
+
+uint32_t BinaryJournal::checksum(const uint8_t* data, size_t len) {
+    uint32_t crc = 0xFFFFFFFF;
+    for (size_t i = 0; i < len; ++i) {
+        crc ^= data[i];
+        for (int j = 0; j < 8; ++j)
+            crc = (crc >> 1) ^ (0xEDB88320 & -(crc & 1));
+    }
+    return crc ^ 0xFFFFFFFF;
+}
+
+void BinaryJournal::write_record(JournalRecordType type, const void* data, size_t size) {
+    if (!wfile_.is_open()) return;
+    uint8_t  rtype = (uint8_t)type;
+    uint32_t psz   = (uint32_t)size;
+    uint32_t crc   = checksum((const uint8_t*)data, size);
+
+    wfile_.write((char*)&rtype, 1);
+    wfile_.write((char*)&psz,   4);
+    wfile_.write((char*)data,   size);
+    wfile_.write((char*)&crc,   4);
+    ++records_written_;
+}
+
+void BinaryJournal::write_order(JournalRecordType type, const Order& order) {
+    JournalOrderRecord rec{};
+    rec.id        = order.id;
+    rec.price     = order.price;
+    rec.qty       = order.qty;
+    rec.timestamp = order.timestamp;
+    rec.side      = (uint8_t)order.side;
+    rec.type      = (uint8_t)order.type;
+    rec.status    = (uint8_t)order.status;
+    strncpy(rec.symbol,    order.symbol.c_str(),    15);
+    strncpy(rec.client_id, order.client_id.c_str(), 31);
+    write_record(type, &rec, sizeof(rec));
+}
+
+void BinaryJournal::write_trade(const Trade& trade) {
+    JournalTradeRecord rec{};
+    rec.trade_id  = trade.trade_id;
+    rec.buy_id    = trade.buy_order_id;
+    rec.sell_id   = trade.sell_order_id;
+    rec.price     = trade.price;
+    rec.qty       = trade.qty;
+    rec.timestamp = trade.timestamp;
+    strncpy(rec.symbol, trade.symbol.c_str(), 15);
+    write_record(JournalRecordType::TRADE, &rec, sizeof(rec));
+}
+
+void BinaryJournal::write_tick(const MarketDataTick& tick) {
+    JournalTickRecord rec{};
+    rec.timestamp  = tick.timestamp;
+    rec.bid_price  = tick.bid_price;
+    rec.bid_qty    = tick.bid_qty;
+    rec.ask_price  = tick.ask_price;
+    rec.ask_qty    = tick.ask_qty;
+    rec.last_price = tick.last_price;
+    rec.last_qty   = tick.last_qty;
+    strncpy(rec.symbol, tick.symbol.c_str(), 15);
+    write_record(JournalRecordType::TICK, &rec, sizeof(rec));
+}
+
+void BinaryJournal::write_session_start() {
+    int64_t ts = now_ns();
+    write_record(JournalRecordType::SESSION_START, &ts, sizeof(ts));
+}
+
+void BinaryJournal::write_session_end() {
+    int64_t ts = now_ns();
+    write_record(JournalRecordType::SESSION_END, &ts, sizeof(ts));
+}
+
+std::vector<BinaryJournal::Record> BinaryJournal::read_all() {
+    std::vector<Record> records;
+    if (!rfile_.is_open()) return records;
+
+    while (rfile_.good() && !rfile_.eof()) {
+        uint8_t rtype;
+        rfile_.read((char*)&rtype, 1);
+        if (rfile_.eof()) break;
+
+        uint32_t psz;
+        rfile_.read((char*)&psz, 4);
+        if (rfile_.fail() || psz > 1<<20) break;
+
+        Record rec;
+        rec.type = (JournalRecordType)rtype;
+        rec.payload.resize(psz);
+        rfile_.read((char*)rec.payload.data(), psz);
+
+        uint32_t crc_stored;
+        rfile_.read((char*)&crc_stored, 4);
+
+        // Verify
+        uint32_t crc_calc = checksum(rec.payload.data(), psz);
+        if (crc_calc != crc_stored) break; // corruption
+
+        records.push_back(std::move(rec));
+    }
+    return records;
+}
+
+// ─── Market Data Generator ────────────────────────────────────────────────────
+
+std::vector<MarketDataTick> MarketDataParser::generate_synthetic(const Config& cfg) {
+    std::mt19937_64 rng(cfg.seed);
+    std::normal_distribution<double> noise(0.0, cfg.volatility);
+    std::uniform_int_distribution<int> qty_dist(100, 5000);
+
+    std::vector<MarketDataTick> ticks;
+    ticks.reserve(cfg.ticks);
+
+    double price = cfg.start_price;
+    double spread = cfg.start_price * cfg.spread_bps / 10000.0;
+
+    for (int i = 0; i < cfg.ticks; ++i) {
+        // Geometric brownian motion tick
+        price *= (1.0 + noise(rng));
+        if (price <= 0) price = 0.01;
+
+        spread = price * cfg.spread_bps / 10000.0;
+
+        MarketDataTick tick{};
+        tick.timestamp  = cfg.start_ts + (int64_t)i * cfg.tick_interval_ns;
+        tick.symbol     = cfg.symbol;
+        tick.bid_price  = to_price(price - spread / 2.0);
+        tick.ask_price  = to_price(price + spread / 2.0);
+        tick.bid_qty    = qty_dist(rng);
+        tick.ask_qty    = qty_dist(rng);
+        tick.last_price = to_price(price);
+        tick.last_qty   = qty_dist(rng) / 2;
+        ticks.push_back(tick);
+    }
+    return ticks;
+}
+
+std::vector<MarketDataTick> MarketDataParser::parse_csv(const std::string& path) {
+    std::vector<MarketDataTick> ticks;
+    std::ifstream f(path);
+    if (!f.good()) return ticks;
+
+    std::string line;
+    std::getline(f, line); // skip header
+
+    while (std::getline(f, line)) {
+        if (line.empty()) continue;
+        std::istringstream ss(line);
+        std::string tok;
+        std::vector<std::string> cols;
+        while (std::getline(ss, tok, ',')) cols.push_back(tok);
+        if (cols.size() < 7) continue;
+
+        MarketDataTick tick{};
+        try {
+            tick.timestamp  = std::stoll(cols[0]);
+            tick.symbol     = cols[1];
+            tick.bid_price  = to_price(std::stod(cols[2]));
+            tick.bid_qty    = std::stoll(cols[3]);
+            tick.ask_price  = to_price(std::stod(cols[4]));
+            tick.ask_qty    = std::stoll(cols[5]);
+            tick.last_price = to_price(std::stod(cols[6]));
+            tick.last_qty   = cols.size() > 7 ? std::stoll(cols[7]) : 0;
+            ticks.push_back(tick);
+        } catch (...) { continue; }
+    }
+    return ticks;
+}
+
+} // namespace hft

src/journal/journal.hpp

@@ -0,0 +1,63 @@
+#pragma once
+#include "core/types.hpp"
+#include <fstream>
+#include <string>
+#include <vector>
+#include <cstring>
+
+namespace hft {
+
+enum class JournalRecordType : uint8_t {
+    ORDER_NEW=1, ORDER_CANCEL=2, ORDER_MODIFY=3, TRADE=4,
+    TICK=5, SNAPSHOT=6, SESSION_START=7, SESSION_END=8
+};
+
+#pragma pack(push, 1)
+struct JournalOrderRecord {
+    OrderId id; int64_t price; int64_t qty; int64_t timestamp;
+    uint8_t side; uint8_t type; uint8_t status;
+    char symbol[16]; char client_id[32];
+};
+struct JournalTradeRecord {
+    uint64_t trade_id; OrderId buy_id; OrderId sell_id;
+    int64_t price; int64_t qty; int64_t timestamp; char symbol[16];
+};
+struct JournalTickRecord {
+    int64_t timestamp, bid_price, bid_qty, ask_price, ask_qty, last_price, last_qty;
+    char symbol[16];
+};
+#pragma pack(pop)
+
+class BinaryJournal {
+public:
+    explicit BinaryJournal(const std::string& path);
+    ~BinaryJournal();
+    bool open_write(); bool open_read(); void close();
+    void write_order(JournalRecordType type, const Order& order);
+    void write_trade(const Trade& trade);
+    void write_tick(const MarketDataTick& tick);
+    void write_session_start(); void write_session_end();
+    struct Record { JournalRecordType type; std::vector<uint8_t> payload; };
+    std::vector<Record> read_all();
+    size_t records_written() const { return records_written_; }
+private:
+    std::string path_;
+    std::ofstream wfile_; std::ifstream rfile_;
+    size_t records_written_ = 0;
+    uint32_t checksum(const uint8_t* data, size_t len);
+    void write_record(JournalRecordType type, const void* data, size_t size);
+};
+
+class MarketDataParser {
+public:
+    struct Config {
+        std::string symbol = "AAPL"; double start_price = 150.0;
+        double volatility = 0.001; double spread_bps = 5.0; int ticks = 10000;
+        int64_t start_ts = 1700000000000000000LL; int64_t tick_interval_ns = 100000;
+        uint64_t seed = 42;
+    };
+    static std::vector<MarketDataTick> generate_synthetic(const Config& cfg);
+    static std::vector<MarketDataTick> parse_csv(const std::string& path);
+};
+
+} // namespace hft

src/main.cpp

@@ -0,0 +1,374 @@
+#include "core/simulator.hpp"
+#include "core/types.hpp"
+#include "strategy/strategy.hpp"
+#include "network/serializer.hpp"
+
+// httplib single-header
+#define CPPHTTPLIB_OPENSSL_SUPPORT 0
+#include "httplib.h"
+
+#include <iostream>
+#include <sstream>
+#include <string>
+#include <thread>
+#include <atomic>
+#include <vector>
+#include <deque>
+#include <mutex>
+#include <unordered_map>
+#include <memory>
+#include <cstring>
+
+using namespace hft;
+
+// ── Global state ──────────────────────────────────────────────────────────────
+static RiskLimits g_limits;
+static std::unique_ptr<ExchangeSimulator> g_sim;
+static std::vector<MarketDataTick> g_tick_feed;
+static std::atomic<bool> g_feed_running{false};
+static std::mutex g_feed_mtx;
+
+static std::deque<std::string> g_recent_trades;   // JSON strings, max 200
+static std::deque<std::string> g_recent_orders;
+static std::mutex g_log_mtx;
+static const int MAX_LOG = 200;
+
+static void log_trade(const Trade& t) {
+    std::lock_guard<std::mutex> lk(g_log_mtx);
+    g_recent_trades.push_back(trade_to_json(t));
+    if ((int)g_recent_trades.size() > MAX_LOG) g_recent_trades.pop_front();
+}
+
+static void log_order(const Order& o) {
+    std::lock_guard<std::mutex> lk(g_log_mtx);
+    g_recent_orders.push_back(order_to_json(o));
+    if ((int)g_recent_orders.size() > MAX_LOG) g_recent_orders.pop_front();
+}
+
+// ── Simple JSON param parser ──────────────────────────────────────────────────
+static std::string json_get(const std::string& body, const std::string& key) {
+    // Extremely basic key extraction — good enough for our controlled API
+    auto pos = body.find("\"" + key + "\"");
+    if (pos == std::string::npos) return "";
+    pos = body.find(":", pos);
+    if (pos == std::string::npos) return "";
+    ++pos;
+    while (pos < body.size() && (body[pos] == ' ' || body[pos] == '\t')) ++pos;
+    if (pos >= body.size()) return "";
+    if (body[pos] == '"') {
+        ++pos;
+        size_t end = body.find('"', pos);
+        return body.substr(pos, end - pos);
+    }
+    size_t end = body.find_first_of(",}\n", pos);
+    return body.substr(pos, end - pos);
+}
+
+static void reset_sim() {
+    g_sim = std::make_unique<ExchangeSimulator>(g_limits);
+    // Default symbols
+    for (auto& sym : {"AAPL", "GOOG", "MSFT", "TSLA", "NVDA"})
+        g_sim->add_symbol(sym);
+    g_sim->set_trade_callback(log_trade);
+    g_sim->set_order_callback(log_order);
+}
+
+int main(int argc, char* argv[]) {
+    int port = 7860; // HuggingFace default
+    if (argc > 1) port = std::atoi(argv[1]);
+
+    g_limits.max_order_qty    = 10000;
+    g_limits.max_position     = 500000;
+    g_limits.max_notional_usd = 50000000.0;
+    g_limits.max_orders_per_sec = 2000;
+    reset_sim();
+
+    // Pre-generate tick feed
+    {
+        const char* syms[] = {"AAPL", "GOOG", "MSFT", "TSLA", "NVDA"};
+        double prices[] = {185.0, 140.0, 375.0, 245.0, 485.0};
+        for (int i = 0; i < 5; ++i) {
+            MarketDataParser::Config cfg;
+            cfg.symbol = syms[i]; cfg.start_price = prices[i];
+            cfg.ticks  = 2000; cfg.volatility = 0.0008;
+            cfg.seed   = 42 + i;
+            auto ticks = MarketDataParser::generate_synthetic(cfg);
+            for (auto& t : ticks) g_tick_feed.push_back(t);
+        }
+        // Sort by timestamp
+        std::sort(g_tick_feed.begin(), g_tick_feed.end(),
+            [](auto& a, auto& b){ return a.timestamp < b.timestamp; });
+    }
+
+    httplib::Server svr;
+
+    // CORS
+    svr.set_default_headers({
+        {"Access-Control-Allow-Origin",  "*"},
+        {"Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS"},
+        {"Access-Control-Allow-Headers", "Content-Type"}
+    });
+    svr.Options(".*", [](auto&, auto& res){ res.status = 204; });
+
+    // ── GET /api/status ──────────────────────────────────────────────────────
+    svr.Get("/api/status", [](const httplib::Request&, httplib::Response& res) {
+        auto& s = *g_sim;
+        std::string body = "{\"status\":\"ok\""
+            ",\"total_orders\":" + J::num(s.total_orders()) +
+            ",\"total_trades\":" + J::num(s.total_trades()) +
+            ",\"total_rejects\":" + J::num(s.total_rejects()) +
+            ",\"total_pnl\":" + J::num(s.total_pnl()) +
+            ",\"order_p50_us\":" + J::num(s.order_latency().p50_ns / 1000.0) +
+            ",\"order_p99_us\":" + J::num(s.order_latency().p99_ns / 1000.0) +
+            ",\"tick_p50_us\":"  + J::num(s.tick_latency().p50_ns / 1000.0) +
+            ",\"tick_p99_us\":"  + J::num(s.tick_latency().p99_ns / 1000.0) +
+            ",\"risk_checked\":" + J::num(s.risk().orders_checked()) +
+            ",\"risk_rejected\":" + J::num(s.risk().orders_rejected()) +
+            ",\"feed_size\":" + J::num((int64_t)g_tick_feed.size()) +
+            "}";
+        res.set_content(body, "application/json");
+    });
+
+    // ── GET /api/book/:symbol ─────────────────────────────────────────────────
+    svr.Get(R"(/api/book/([A-Z]+))", [](const httplib::Request& req, httplib::Response& res) {
+        auto sym = req.matches[1].str();
+        auto snap = g_sim->get_snapshot(sym);
+        if (snap.symbol.empty()) {
+            res.status = 404;
+            res.set_content("{\"error\":\"symbol not found\"}", "application/json");
+            return;
+        }
+        res.set_content(snapshot_to_json(snap), "application/json");
+    });
+
+    // ── GET /api/positions ───────────────────────────────────────────────────
+    svr.Get("/api/positions", [](const httplib::Request&, httplib::Response& res) {
+        auto pos = g_sim->all_positions();
+        std::string body = "[";
+        bool first = true;
+        for (auto& [sym, p] : pos) {
+            if (!first) body += ",";
+            body += position_to_json(p);
+            first = false;
+        }
+        body += "]";
+        res.set_content(body, "application/json");
+    });
+
+    // ── GET /api/trades ───────────────────────────────────────────────────────
+    svr.Get("/api/trades", [](const httplib::Request&, httplib::Response& res) {
+        std::lock_guard<std::mutex> lk(g_log_mtx);
+        std::string body = "[";
+        bool first = true;
+        for (auto& t : g_recent_trades) {
+            if (!first) body += ",";
+            body += t; first = false;
+        }
+        body += "]";
+        res.set_content(body, "application/json");
+    });
+
+    // ── GET /api/orders ───────────────────────────────────────────────────────
+    svr.Get("/api/orders", [](const httplib::Request&, httplib::Response& res) {
+        std::lock_guard<std::mutex> lk(g_log_mtx);
+        std::string body = "[";
+        bool first = true;
+        for (auto& o : g_recent_orders) {
+            if (!first) body += ",";
+            body += o; first = false;
+        }
+        body += "]";
+        res.set_content(body, "application/json");
+    });
+
+    // ── POST /api/order ──────────────────────────────────────────────────────
+    svr.Post("/api/order", [](const httplib::Request& req, httplib::Response& res) {
+        auto& body = req.body;
+        Order order;
+        order.id      = g_sim->next_order_id();
+        order.symbol  = json_get(body, "symbol");
+        std::string side_s = json_get(body, "side");
+        order.side    = (side_s == "SELL") ? Side::SELL : Side::BUY;
+        std::string type_s = json_get(body, "type");
+        if      (type_s == "MARKET") order.type = OrderType::MARKET;
+        else if (type_s == "IOC")    order.type = OrderType::IOC;
+        else if (type_s == "FOK")    order.type = OrderType::FOK;
+        else                          order.type = OrderType::LIMIT;
+        try {
+            order.price = to_price(std::stod(json_get(body, "price")));
+            order.qty   = std::stoll(json_get(body, "qty"));
+        } catch (...) {
+            res.status = 400;
+            res.set_content("{\"error\":\"invalid price or qty\"}", "application/json");
+            return;
+        }
+        order.client_id = json_get(body, "client_id");
+
+        auto result = g_sim->submit_order(order);
+        std::string resp = "{\"approved\":" + J::boolean(result.approved) +
+                           ",\"order\":" + order_to_json(order) +
+                           ",\"reject_reason\":" + J::str(result.reject_reason) +
+                           ",\"trades\":[";
+        for (size_t i = 0; i < result.trades.size(); ++i) {
+            if (i) resp += ",";
+            resp += trade_to_json(result.trades[i]);
+        }
+        resp += "]}";
+        res.set_content(resp, "application/json");
+    });
+
+    // ── DELETE /api/order/:id/:symbol ────────────────────────────────────────
+    svr.Delete(R"(/api/order/(\d+)/([A-Z]+))", [](const httplib::Request& req, httplib::Response& res) {
+        OrderId id = std::stoull(req.matches[1].str());
+        std::string sym = req.matches[2].str();
+        bool ok = g_sim->cancel_order(sym, id);
+        res.set_content("{\"cancelled\":" + J::boolean(ok) + "}", "application/json");
+    });
+
+    // ── POST /api/feed/step?n=N ──────────────────────────────────────────────
+    // Advance feed by N ticks, return the ticks
+    static std::atomic<size_t> g_feed_idx{0};
+    svr.Post("/api/feed/step", [&g_feed_idx](const httplib::Request& req, httplib::Response& res) {
+        int n = 1;
+        if (req.has_param("n")) {
+            try { n = std::stoi(req.get_param_value("n")); } catch(...) {}
+        }
+        n = std::min(n, 100);
+
+        std::string body = "[";
+        bool first = true;
+        for (int i = 0; i < n; ++i) {
+            size_t idx = g_feed_idx.fetch_add(1) % g_tick_feed.size();
+            auto& tick = g_tick_feed[idx];
+            g_sim->on_tick(tick);
+            if (!first) body += ",";
+            body += "{\"symbol\":" + J::str(tick.symbol) +
+                    ",\"bid\":" + J::num(from_price(tick.bid_price)) +
+                    ",\"ask\":" + J::num(from_price(tick.ask_price)) +
+                    ",\"last\":" + J::num(from_price(tick.last_price)) +
+                    ",\"bid_qty\":" + J::num(tick.bid_qty) +
+                    ",\"ask_qty\":" + J::num(tick.ask_qty) +
+                    ",\"ts\":" + J::num(tick.timestamp) + "}";
+            first = false;
+        }
+        body += "]";
+        res.set_content(body, "application/json");
+    });
+
+    // ── POST /api/backtest ───────────────────────────────────────────────────
+    svr.Post("/api/backtest", [](const httplib::Request& req, httplib::Response& res) {
+        std::string strategy_name = json_get(req.body, "strategy");
+        std::string symbol        = json_get(req.body, "symbol");
+        int ticks = 5000;
+        try { ticks = std::stoi(json_get(req.body, "ticks")); } catch(...) {}
+        ticks = std::min(std::max(ticks, 100), 50000);
+
+        double start_price = 150.0;
+        try { start_price = std::stod(json_get(req.body, "start_price")); } catch(...) {}
+
+        if (symbol.empty()) symbol = "AAPL";
+
+        // Generate fresh tick set
+        MarketDataParser::Config cfg;
+        cfg.symbol      = symbol;
+        cfg.start_price = start_price;
+        cfg.ticks       = ticks;
+        cfg.volatility  = 0.001;
+        cfg.seed        = 123;
+        auto bt_ticks   = MarketDataParser::generate_synthetic(cfg);
+
+        RiskLimits rl;
+        rl.max_order_qty    = 10000;
+        rl.max_position     = 200000;
+        rl.max_notional_usd = 100000000.0;
+        rl.max_orders_per_sec = 5000;
+
+        Backtester bt(rl);
+        bt.add_symbol(symbol);
+
+        std::unique_ptr<IStrategy> strat;
+        if (strategy_name == "Momentum")
+            strat = std::make_unique<MomentumStrategy>();
+        else if (strategy_name == "MeanReversion")
+            strat = std::make_unique<MeanReversionStrategy>();
+        else
+            strat = std::make_unique<MarketMakingStrategy>();
+        bt.set_strategy(std::move(strat));
+
+        auto result = bt.run(bt_ticks, false);
+        res.set_content(backtest_result_to_json(result), "application/json");
+    });
+
+    // ── POST /api/risk/limits ────────────────────────────────────────────────
+    svr.Post("/api/risk/limits", [](const httplib::Request& req, httplib::Response& res) {
+        try {
+            auto& b = req.body;
+            g_limits.max_order_qty    = std::stoll(json_get(b, "max_order_qty"));
+            g_limits.max_position     = std::stoll(json_get(b, "max_position"));
+            g_limits.max_notional_usd = std::stod(json_get(b, "max_notional_usd"));
+            g_limits.max_orders_per_sec = std::stoi(json_get(b, "max_orders_per_sec"));
+            g_sim->risk().set_limits(g_limits);
+            res.set_content("{\"ok\":true}", "application/json");
+        } catch (...) {
+            res.status = 400;
+            res.set_content("{\"error\":\"bad limits\"}", "application/json");
+        }
+    });
+
+    // ── GET /api/risk/limits ──────────────────────────────────────────────────
+    svr.Get("/api/risk/limits", [](const httplib::Request&, httplib::Response& res) {
+        auto l = g_sim->risk().get_limits();
+        res.set_content(
+            "{\"max_order_qty\":" + J::num(l.max_order_qty) +
+            ",\"max_position\":" + J::num(l.max_position) +
+            ",\"max_notional_usd\":" + J::num(l.max_notional_usd, 0) +
+            ",\"max_orders_per_sec\":" + J::num((int64_t)l.max_orders_per_sec) +
+            ",\"enabled\":" + J::boolean(l.enabled) + "}",
+            "application/json");
+    });
+
+    // ── POST /api/reset ───────────────────────────────────────────────────────
+    svr.Post("/api/reset", [](const httplib::Request&, httplib::Response& res) {
+        {
+            std::lock_guard<std::mutex> lk(g_log_mtx);
+            g_recent_trades.clear();
+            g_recent_orders.clear();
+        }
+        reset_sim();
+        res.set_content("{\"reset\":true}", "application/json");
+    });
+
+    // ── GET /api/symbols ───────────────────────────────────────────────────────
+    svr.Get("/api/symbols", [](const httplib::Request&, httplib::Response& res) {
+        auto syms = g_sim->symbols();
+        std::string body = "[";
+        for (size_t i = 0; i < syms.size(); ++i) {
+            if (i) body += ",";
+            body += J::str(syms[i]);
+        }
+        body += "]";
+        res.set_content(body, "application/json");
+    });
+
+    // ── Serve frontend ────────────────────────────────────────────────────────
+    svr.set_mount_point("/", "./frontend/dist");
+    // Fallback for SPA
+    svr.Get("/.*", [](const httplib::Request&, httplib::Response& res) {
+        std::ifstream f("./frontend/dist/index.html");
+        if (f.good()) {
+            std::string content((std::istreambuf_iterator<char>(f)),
+                                 std::istreambuf_iterator<char>());
+            res.set_content(content, "text/html");
+        } else {
+            res.status = 404;
+        }
+    });
+
+    std::cout << "╔══════════════════════════════════════════╗\n";
+    std::cout << "║  HFT Exchange Simulator                  ║\n";
+    std::cout << "║  Listening on http://0.0.0.0:" << port << "        ║\n";
+    std::cout << "╚══════════════════════════════════════════╝\n";
+
+    svr.listen("0.0.0.0", port);
+    return 0;
+}

src/network/serializer.hpp

@@ -0,0 +1,133 @@
+#pragma once
+#include "core/simulator.hpp"
+#include "core/types.hpp"
+#include <string>
+#include <sstream>
+#include <iomanip>
+
+namespace hft {
+
+struct J {
+    static std::string str(const std::string& s) {
+        std::ostringstream o; o << "\"";
+        for (char c : s) {
+            if (c == '"') o << "\\\"";
+            else if (c == '\\') o << "\\\\";
+            else o << c;
+        }
+        o << "\""; return o.str();
+    }
+    static std::string num(double v, int prec = 4) {
+        std::ostringstream o; o << std::fixed << std::setprecision(prec) << v; return o.str();
+    }
+    static std::string num(int64_t v)  { return std::to_string(v); }
+    static std::string num(uint64_t v) { return std::to_string(v); }
+    static std::string boolean(bool b) { return b ? "true" : "false"; }
+};
+
+inline std::string order_to_json(const Order& o) {
+    return "{\"id\":"         + J::num(o.id) +
+           ",\"symbol\":"     + J::str(o.symbol) +
+           ",\"side\":"       + J::str(o.side == Side::BUY ? "BUY" : "SELL") +
+           ",\"type\":"       + J::str([&]{ switch(o.type){
+               case OrderType::LIMIT:  return "LIMIT";
+               case OrderType::MARKET: return "MARKET";
+               case OrderType::IOC:    return "IOC";
+               case OrderType::FOK:    return "FOK";
+           } return "LIMIT"; }()) +
+           ",\"price\":"      + J::num(from_price(o.price)) +
+           ",\"qty\":"        + J::num(o.qty) +
+           ",\"filled_qty\":" + J::num(o.filled_qty) +
+           ",\"status\":"     + J::str([&]{ switch(o.status){
+               case OrderStatus::PENDING:          return "PENDING";
+               case OrderStatus::NEW:              return "NEW";
+               case OrderStatus::PARTIALLY_FILLED: return "PARTIALLY_FILLED";
+               case OrderStatus::FILLED:           return "FILLED";
+               case OrderStatus::CANCELLED:        return "CANCELLED";
+               case OrderStatus::REJECTED:         return "REJECTED";
+               case OrderStatus::EXPIRED:          return "EXPIRED";
+           } return "UNKNOWN"; }()) +
+           ",\"timestamp\":"  + J::num(o.timestamp) + "}";
+}
+
+inline std::string trade_to_json(const Trade& t) {
+    return "{\"trade_id\":"      + J::num(t.trade_id) +
+           ",\"buy_order_id\":"  + J::num(t.buy_order_id) +
+           ",\"sell_order_id\":" + J::num(t.sell_order_id) +
+           ",\"symbol\":"        + J::str(t.symbol) +
+           ",\"price\":"         + J::num(from_price(t.price)) +
+           ",\"qty\":"           + J::num(t.qty) +
+           ",\"timestamp\":"     + J::num(t.timestamp) + "}";
+}
+
+inline std::string snapshot_to_json(const OrderBookSnapshot& s, int depth = 10) {
+    std::string bids = "[";
+    for (int i = 0; i < (int)s.bids.size() && i < depth; ++i) {
+        if (i) bids += ",";
+        bids += "{\"price\":" + J::num(from_price(s.bids[i].price)) +
+                ",\"qty\":"   + J::num(s.bids[i].qty) +
+                ",\"orders\":" + J::num((int64_t)s.bids[i].order_count) + "}";
+    }
+    bids += "]";
+    std::string asks = "[";
+    for (int i = 0; i < (int)s.asks.size() && i < depth; ++i) {
+        if (i) asks += ",";
+        asks += "{\"price\":" + J::num(from_price(s.asks[i].price)) +
+                ",\"qty\":"   + J::num(s.asks[i].qty) +
+                ",\"orders\":" + J::num((int64_t)s.asks[i].order_count) + "}";
+    }
+    asks += "]";
+    return "{\"symbol\":"    + J::str(s.symbol) +
+           ",\"timestamp\":" + J::num(s.timestamp) +
+           ",\"best_bid\":"  + J::num(from_price(s.best_bid())) +
+           ",\"best_ask\":"  + J::num(from_price(s.best_ask())) +
+           ",\"mid\":"       + J::num(from_price(s.mid())) +
+           ",\"spread\":"    + J::num(s.spread(), 6) +
+           ",\"bids\":"      + bids +
+           ",\"asks\":"      + asks + "}";
+}
+
+inline std::string position_to_json(const Position& p) {
+    return "{\"symbol\":"         + J::str(p.symbol) +
+           ",\"net_qty\":"        + J::num(p.net_qty) +
+           ",\"avg_price\":"      + J::num(p.avg_price) +
+           ",\"realized_pnl\":"   + J::num(p.realized_pnl) +
+           ",\"unrealized_pnl\":" + J::num(p.unrealized_pnl) +
+           ",\"notional\":"       + J::num(p.notional()) + "}";
+}
+
+inline std::string backtest_result_to_json(const BacktestResult& r) {
+    std::string equity = "[";
+    for (size_t i = 0; i < r.equity_curve.size(); ++i) {
+        if (i) equity += ",";
+        equity += J::num(r.equity_curve[i]);
+    }
+    equity += "]";
+    std::string trades_str = "[";
+    for (size_t i = 0; i < r.trades.size() && i < 500; ++i) {
+        if (i) trades_str += ",";
+        trades_str += trade_to_json(r.trades[i]);
+    }
+    trades_str += "]";
+    return "{\"strategy\":"        + J::str(r.strategy_name) +
+           ",\"ticks_processed\":" + J::num(r.ticks_processed) +
+           ",\"orders_submitted\":" + J::num(r.orders_submitted) +
+           ",\"orders_filled\":"   + J::num(r.orders_filled) +
+           ",\"orders_rejected\":" + J::num(r.orders_rejected) +
+           ",\"trades_count\":"    + J::num(r.trades_count) +
+           ",\"total_pnl\":"       + J::num(r.total_pnl) +
+           ",\"realized_pnl\":"    + J::num(r.realized_pnl) +
+           ",\"unrealized_pnl\":"  + J::num(r.unrealized_pnl) +
+           ",\"max_drawdown\":"    + J::num(r.max_drawdown) +
+           ",\"sharpe\":"          + J::num(r.sharpe) +
+           ",\"order_p50_us\":"    + J::num(r.order_latency.p50_ns / 1000.0) +
+           ",\"order_p99_us\":"    + J::num(r.order_latency.p99_ns / 1000.0) +
+           ",\"order_avg_us\":"    + J::num(r.order_latency.avg_us()) +
+           ",\"tick_p50_us\":"     + J::num(r.tick_latency.p50_ns / 1000.0) +
+           ",\"tick_p99_us\":"     + J::num(r.tick_latency.p99_ns / 1000.0) +
+           ",\"throughput_eps\":"  + J::num(r.throughput_eps) +
+           ",\"equity_curve\":"    + equity +
+           ",\"trades\":"          + trades_str + "}";
+}
+
+} // namespace hft

src/risk/risk_manager.cpp

@@ -0,0 +1,135 @@
+#include "risk/risk_manager.hpp"
+#include <cmath>
+#include <algorithm>
+
+namespace hft {
+
+RiskManager::RiskManager(RiskLimits limits) : limits_(std::move(limits)) {}
+
+int RiskManager::orders_in_last_second() {
+    int64_t now    = now_ns();
+    int64_t cutoff = now - 1'000'000'000LL;
+    while (!order_timestamps_ns_.empty() && order_timestamps_ns_.front() < cutoff)
+        order_timestamps_ns_.pop_front();
+    return (int)order_timestamps_ns_.size();
+}
+
+RiskResult RiskManager::check_order(const Order& order, double current_price) {
+    std::lock_guard<std::mutex> lock(mtx_);
+    ++stats_checked_;
+
+    if (!limits_.enabled) {
+        order_timestamps_ns_.push_back(now_ns());
+        return {true, RiskRejectReason::NONE, "OK"};
+    }
+
+    if (order.qty <= 0)
+        return (++stats_rejected_, RiskResult{false, RiskRejectReason::INVALID_QTY, "Quantity must be positive"});
+
+    if (order.type == OrderType::LIMIT && order.price <= 0)
+        return (++stats_rejected_, RiskResult{false, RiskRejectReason::INVALID_PRICE, "Limit price must be positive"});
+
+    if (order.qty > limits_.max_order_qty)
+        return (++stats_rejected_, RiskResult{false, RiskRejectReason::MAX_ORDER_QTY,
+            "Order qty " + std::to_string(order.qty) + " > limit " + std::to_string(limits_.max_order_qty)});
+
+    double price_usd = (current_price > 0) ? current_price : from_price(order.price);
+    double notional  = price_usd * order.qty;
+    if (notional > limits_.max_notional_usd)
+        return (++stats_rejected_, RiskResult{false, RiskRejectReason::MAX_NOTIONAL,
+            "Notional $" + std::to_string(notional) + " > limit $" + std::to_string(limits_.max_notional_usd)});
+
+    auto pit         = positions_.find(order.symbol);
+    Quantity cur_pos = (pit != positions_.end()) ? pit->second.net_qty : 0;
+    Quantity projected = cur_pos + (order.side == Side::BUY ? order.qty : -order.qty);
+    if (std::abs(projected) > limits_.max_position)
+        return (++stats_rejected_, RiskResult{false, RiskRejectReason::MAX_POSITION,
+            "Projected position " + std::to_string(projected) + " > limit " + std::to_string(limits_.max_position)});
+
+    // Rate check — only count approved orders toward the rate limit
+    int rate = orders_in_last_second();
+    if (rate >= limits_.max_orders_per_sec)
+        return (++stats_rejected_, RiskResult{false, RiskRejectReason::MAX_ORDER_RATE,
+            "Order rate " + std::to_string(rate) + "/s >= limit " + std::to_string(limits_.max_orders_per_sec)});
+
+    // All checks passed — record timestamp for rate limiting
+    order_timestamps_ns_.push_back(now_ns());
+    return {true, RiskRejectReason::NONE, "OK"};
+}
+
+void RiskManager::on_fill(const std::string& symbol, Side side, Quantity qty, double fill_price) {
+    std::lock_guard<std::mutex> lock(mtx_);
+    auto& pos  = positions_[symbol];
+    pos.symbol = symbol;
+
+    int64_t signed_qty = (side == Side::BUY) ? (int64_t)qty : -(int64_t)qty;
+    bool adding = (pos.net_qty == 0) ||
+                  (side == Side::BUY  && pos.net_qty > 0) ||
+                  (side == Side::SELL && pos.net_qty < 0);
+
+    if (adding) {
+        double total_cost = pos.avg_price * std::abs((double)pos.net_qty) + fill_price * qty;
+        pos.net_qty += signed_qty;
+        pos.avg_price = (pos.net_qty != 0)
+            ? total_cost / std::abs((double)pos.net_qty)
+            : 0.0;
+    } else {
+        Quantity closing = std::min(qty, (Quantity)std::abs(pos.net_qty));
+        Quantity opening = qty - closing;
+
+        double realized = (fill_price - pos.avg_price) * closing *
+                          (pos.net_qty > 0 ? 1.0 : -1.0);
+        pos.realized_pnl += realized;
+        pos.net_qty += signed_qty;
+
+        if (pos.net_qty == 0) {
+            pos.avg_price = 0.0;
+        } else if (opening > 0) {
+            pos.avg_price = fill_price;
+        }
+    }
+
+    if (pos.net_qty != 0) {
+        double mkt = market_prices_.count(symbol) ? market_prices_.at(symbol) : fill_price;
+        pos.unrealized_pnl = (mkt - pos.avg_price) * pos.net_qty;
+    } else {
+        pos.unrealized_pnl = 0.0;
+    }
+}
+
+void RiskManager::update_market_price(const std::string& sym, double px) {
+    std::lock_guard<std::mutex> lock(mtx_);
+    market_prices_[sym] = px;
+    if (positions_.count(sym)) {
+        auto& pos = positions_[sym];
+        pos.unrealized_pnl = (pos.net_qty != 0)
+            ? (px - pos.avg_price) * pos.net_qty
+            : 0.0;
+    }
+}
+
+void RiskManager::on_cancel(const std::string& symbol, const Order& order) {
+    (void)symbol; (void)order;
+}
+
+Position RiskManager::get_position(const std::string& symbol) const {
+    std::lock_guard<std::mutex> lock(mtx_);
+    auto it = positions_.find(symbol);
+    if (it == positions_.end()) return Position{symbol, 0, 0, 0, 0};
+    return it->second;
+}
+
+std::unordered_map<std::string, Position> RiskManager::all_positions() const {
+    std::lock_guard<std::mutex> lock(mtx_);
+    return positions_;
+}
+
+double RiskManager::total_pnl() const {
+    std::lock_guard<std::mutex> lock(mtx_);
+    double total = 0;
+    for (auto& [sym, pos] : positions_)
+        total += pos.realized_pnl + pos.unrealized_pnl;
+    return total;
+}
+
+} // namespace hft

src/risk/risk_manager.hpp

@@ -0,0 +1,63 @@
+#pragma once
+#include "core/types.hpp"
+#include <unordered_map>
+#include <string>
+#include <deque>
+#include <mutex>
+
+namespace hft {
+
+enum class RiskRejectReason {
+    NONE,
+    MAX_ORDER_QTY,
+    MAX_POSITION,
+    MAX_NOTIONAL,
+    MAX_ORDER_RATE,
+    INVALID_PRICE,
+    INVALID_QTY,
+    SYMBOL_NOT_ALLOWED
+};
+
+struct RiskResult {
+    bool   approved = false;
+    RiskRejectReason reason = RiskRejectReason::NONE;
+    std::string message;
+};
+
+class RiskManager {
+public:
+    explicit RiskManager(RiskLimits limits);
+
+    RiskResult check_order(const Order& order, double current_price = 0.0);
+    void on_fill(const std::string& symbol, Side side, Quantity qty, double fill_price);
+    void on_cancel(const std::string& symbol, const Order& order);
+
+    Position get_position(const std::string& symbol) const;
+    std::unordered_map<std::string, Position> all_positions() const;
+    double total_pnl() const;
+
+    void set_limits(RiskLimits l) { limits_ = l; }
+    RiskLimits get_limits() const { return limits_; }
+    void update_market_price(const std::string& sym, double px);
+
+    // Stats
+    int64_t orders_checked()   const { return stats_checked_; }
+    int64_t orders_rejected()  const { return stats_rejected_; }
+
+private:
+    RiskLimits limits_;
+    mutable std::mutex mtx_;
+
+    std::unordered_map<std::string, Position> positions_;
+    std::unordered_map<std::string, double>   market_prices_;
+
+    // Order rate tracking (sliding window 1 sec)
+    std::deque<int64_t> order_timestamps_ns_;
+
+    int64_t stats_checked_  = 0;
+    int64_t stats_rejected_ = 0;
+
+    int orders_in_last_second();
+};
+
+} // namespace hft

src/strategy/strategy.hpp

@@ -0,0 +1,239 @@
+#pragma once
+#include "core/types.hpp"
+#include <vector>
+#include <string>
+#include <functional>
+#include <memory>
+#include <deque>
+#include <cmath>
+
+namespace hft {
+
+struct StrategySignal {
+    enum class Action { NONE, BUY, SELL, CANCEL, CANCEL_ALL } action = Action::NONE;
+    std::string symbol;
+    OrderType   type      = OrderType::LIMIT;
+    Price       price     = 0;
+    Quantity    qty       = 0;
+    OrderId     cancel_id = 0;
+    std::string reason;
+};
+
+class IStrategy {
+public:
+    virtual ~IStrategy() = default;
+    virtual std::string name() const = 0;
+    virtual void on_init(const std::string& symbol) { (void)symbol; }
+    virtual std::vector<StrategySignal> on_tick(const MarketDataTick& tick,
+                                                 const OrderBookSnapshot& book) = 0;
+    virtual void on_order_update(const Order& order) { (void)order; }
+    virtual void on_trade(const Trade& trade)         { (void)trade; }
+    virtual std::string summary() const               { return ""; }
+};
+
+class MarketMakingStrategy : public IStrategy {
+public:
+    explicit MarketMakingStrategy(double spread_bps = 5.0, Quantity qty = 100)
+        : spread_bps_(spread_bps), qty_(qty) {}
+
+    std::string name() const override { return "MarketMaking"; }
+
+    std::vector<StrategySignal> on_tick(const MarketDataTick& tick,
+                                         const OrderBookSnapshot& book) override {
+        std::vector<StrategySignal> sigs;
+        if (book.bids.empty() || book.asks.empty()) return sigs;
+
+        double mid  = from_price(book.mid());
+        double half = mid * spread_bps_ / 20000.0;
+
+        if (bid_id_) {
+            StrategySignal s;
+            s.action    = StrategySignal::Action::CANCEL;
+            s.cancel_id = bid_id_;
+            sigs.push_back(s);
+            bid_id_ = 0;
+        }
+        if (ask_id_) {
+            StrategySignal s;
+            s.action    = StrategySignal::Action::CANCEL;
+            s.cancel_id = ask_id_;
+            sigs.push_back(s);
+            ask_id_ = 0;
+        }
+
+        StrategySignal buy;
+        buy.action = StrategySignal::Action::BUY;
+        buy.symbol = tick.symbol;
+        buy.type   = OrderType::LIMIT;
+        buy.price  = to_price(mid - half);
+        buy.qty    = qty_;
+        buy.reason = "MM_BID";
+        sigs.push_back(buy);
+
+        StrategySignal sell;
+        sell.action = StrategySignal::Action::SELL;
+        sell.symbol = tick.symbol;
+        sell.type   = OrderType::LIMIT;
+        sell.price  = to_price(mid + half);
+        sell.qty    = qty_;
+        sell.reason = "MM_ASK";
+        sigs.push_back(sell);
+
+        return sigs;
+    }
+
+    void on_order_update(const Order& order) override {
+        if (order.status == OrderStatus::REJECTED ||
+            order.status == OrderStatus::CANCELLED ||
+            order.status == OrderStatus::EXPIRED) {
+            if (order.id == bid_id_) bid_id_ = 0;
+            if (order.id == ask_id_) ask_id_ = 0;
+            return;
+        }
+        if (order.status == OrderStatus::NEW) {
+            if (order.side == Side::BUY)  bid_id_ = order.id;
+            if (order.side == Side::SELL) ask_id_ = order.id;
+        }
+        if (order.status == OrderStatus::FILLED) {
+            ++fills_;
+            if (order.id == bid_id_) bid_id_ = 0;
+            if (order.id == ask_id_) ask_id_ = 0;
+        }
+    }
+
+    std::string summary() const override {
+        return "MarketMaking fills=" + std::to_string(fills_);
+    }
+
+private:
+    double   spread_bps_;
+    Quantity qty_;
+    OrderId  bid_id_ = 0;
+    OrderId  ask_id_ = 0;
+    int      fills_  = 0;
+};
+
+class MomentumStrategy : public IStrategy {
+public:
+    explicit MomentumStrategy(int lookback = 20, Quantity qty = 200)
+        : lookback_(lookback), qty_(qty) {}
+
+    std::string name() const override { return "Momentum"; }
+
+    std::vector<StrategySignal> on_tick(const MarketDataTick& tick,
+                                         const OrderBookSnapshot& book) override {
+        std::vector<StrategySignal> sigs;
+        double mid = from_price(tick.last_price);
+        prices_.push_back(mid);
+        if ((int)prices_.size() > lookback_ * 2) prices_.pop_front();
+        if ((int)prices_.size() < lookback_) return sigs;
+
+        int n = (int)prices_.size();
+        double fast = 0, slow = 0;
+        int fast_n = lookback_ / 2;
+        for (int i = n - fast_n; i < n; ++i) fast += prices_[i];
+        fast /= fast_n;
+        for (int i = n - lookback_; i < n; ++i) slow += prices_[i];
+        slow /= lookback_;
+
+        if (fast > slow * 1.0002 && !long_) {
+            StrategySignal s;
+            s.action = StrategySignal::Action::BUY;
+            s.symbol = tick.symbol;
+            s.type   = OrderType::MARKET;
+            s.qty    = qty_;
+            s.reason = "MOMENTUM_LONG";
+            sigs.push_back(s);
+            long_ = true;
+            ++signals_;
+        } else if (fast < slow * 0.9998 && long_) {
+            StrategySignal s;
+            s.action = StrategySignal::Action::SELL;
+            s.symbol = tick.symbol;
+            s.type   = OrderType::MARKET;
+            s.qty    = qty_;
+            s.reason = "MOMENTUM_FLAT";
+            sigs.push_back(s);
+            long_ = false;
+            ++signals_;
+        }
+        return sigs;
+    }
+
+    std::string summary() const override {
+        return "Momentum signals=" + std::to_string(signals_);
+    }
+
+private:
+    int lookback_;
+    Quantity qty_;
+    std::deque<double> prices_;
+    bool long_    = false;
+    int  signals_ = 0;
+};
+
+class MeanReversionStrategy : public IStrategy {
+public:
+    explicit MeanReversionStrategy(int window = 30, double z_entry = 2.0, Quantity qty = 100)
+        : window_(window), z_entry_(z_entry), qty_(qty) {}
+
+    std::string name() const override { return "MeanReversion"; }
+
+    std::vector<StrategySignal> on_tick(const MarketDataTick& tick,
+                                         const OrderBookSnapshot& book) override {
+        std::vector<StrategySignal> sigs;
+        double px = from_price(tick.last_price);
+        buf_.push_back(px);
+        if ((int)buf_.size() > window_) buf_.pop_front();
+        if ((int)buf_.size() < window_) return sigs;
+
+        double mean = 0;
+        for (double v : buf_) mean += v;
+        mean /= window_;
+
+        double var = 0;
+        for (double v : buf_) var += (v - mean) * (v - mean);
+        double stddev = std::sqrt(var / window_);
+        if (stddev < 1e-9) return sigs;
+
+        double z = (px - mean) / stddev;
+
+        if (z < -z_entry_ && !in_trade_) {
+            StrategySignal s;
+            s.action = StrategySignal::Action::BUY;
+            s.symbol = tick.symbol;
+            s.type   = OrderType::LIMIT;
+            s.price  = tick.ask_price;
+            s.qty    = qty_;
+            s.reason = "MR_LONG z=" + std::to_string(z).substr(0, 6);
+            sigs.push_back(s);
+            in_trade_ = true;
+        } else if (z > z_entry_ && !in_trade_) {
+            StrategySignal s;
+            s.action = StrategySignal::Action::SELL;
+            s.symbol = tick.symbol;
+            s.type   = OrderType::LIMIT;
+            s.price  = tick.bid_price;
+            s.qty    = qty_;
+            s.reason = "MR_SHORT z=" + std::to_string(z).substr(0, 6);
+            sigs.push_back(s);
+            in_trade_ = true;
+        } else if (std::abs(z) < 0.3 && in_trade_) {
+            StrategySignal s;
+            s.action = StrategySignal::Action::CANCEL_ALL;
+            s.reason = "MR_EXIT";
+            sigs.push_back(s);
+            in_trade_ = false;
+        }
+        return sigs;
+    }
+
+private:
+    int      window_;
+    double   z_entry_;
+    Quantity qty_;
+    std::deque<double> buf_;
+    bool in_trade_ = false;
+};
+
+} // namespace hft

tests/test_order_book.cpp

@@ -0,0 +1,415 @@
+// tests/test_order_book.cpp
+// Unit tests for the matching engine core
+// Build: cmake --build build --target hft_tests && ./build/hft_tests
+
+#include "core/order_book.hpp"
+#include "core/types.hpp"
+#include <cassert>
+#include <iostream>
+#include <string>
+#include <vector>
+#include <cmath>
+
+using namespace hft;
+
+static int tests_passed = 0;
+static int tests_failed = 0;
+
+#define TEST(name) \
+    void name(); \
+    struct name##_register { name##_register() { std::cout << "  " << #name << "... "; name(); } } name##_instance; \
+    void name()
+
+#define ASSERT_EQ(a, b) do { \
+    if ((a) != (b)) { \
+        std::cerr << "FAIL: " << #a << " == " << (a) << ", expected " << (b) << " at line " << __LINE__ << "\n"; \
+        ++tests_failed; return; \
+    } \
+} while(0)
+
+#define ASSERT_TRUE(x) do { \
+    if (!(x)) { \
+        std::cerr << "FAIL: " << #x << " at line " << __LINE__ << "\n"; \
+        ++tests_failed; return; \
+    } \
+} while(0)
+
+#define PASS() do { std::cout << "PASS\n"; ++tests_passed; } while(0)
+
+// ─── Price Conversion Tests ──────────────────────────────────────────────────
+
+TEST(test_to_price_positive) {
+    ASSERT_EQ(to_price(185.50), 1855000);
+    ASSERT_EQ(to_price(0.0001), 1);
+    ASSERT_EQ(to_price(100.0), 1000000);
+    PASS();
+}
+
+TEST(test_to_price_negative) {
+    ASSERT_EQ(to_price(-1.5), -15000);
+    ASSERT_EQ(to_price(-0.0001), -1);
+    ASSERT_EQ(to_price(-100.0), -1000000);
+    PASS();
+}
+
+TEST(test_to_price_roundtrip) {
+    double original = 185.4567;
+    Price p = to_price(original);
+    double back = from_price(p);
+    ASSERT_TRUE(std::abs(back - original) < 0.00005);
+    PASS();
+}
+
+// ─── Order Book: Basic Insert ────────────────────────────────────────────────
+
+TEST(test_add_limit_order_no_match) {
+    OrderBook book("AAPL");
+    Order buy;
+    buy.id = 1; buy.symbol = "AAPL"; buy.side = Side::BUY;
+    buy.type = OrderType::LIMIT; buy.price = to_price(185.0); buy.qty = 100;
+
+    auto trades = book.add_order(buy);
+    ASSERT_EQ(trades.size(), 0u);
+    ASSERT_EQ(book.order_count(), 1u);
+    ASSERT_EQ(book.bid_levels(), 1u);
+    ASSERT_EQ(book.ask_levels(), 0u);
+    ASSERT_EQ(book.best_bid(), to_price(185.0));
+    PASS();
+}
+
+TEST(test_multiple_levels) {
+    OrderBook book("AAPL");
+    Order o1, o2, o3;
+    o1.id = 1; o1.symbol = "AAPL"; o1.side = Side::BUY;
+    o1.type = OrderType::LIMIT; o1.price = to_price(185.0); o1.qty = 100;
+
+    o2.id = 2; o2.symbol = "AAPL"; o2.side = Side::BUY;
+    o2.type = OrderType::LIMIT; o2.price = to_price(184.0); o2.qty = 200;
+
+    o3.id = 3; o3.symbol = "AAPL"; o3.side = Side::SELL;
+    o3.type = OrderType::LIMIT; o3.price = to_price(186.0); o3.qty = 150;
+
+    book.add_order(o1);
+    book.add_order(o2);
+    book.add_order(o3);
+
+    ASSERT_EQ(book.bid_levels(), 2u);
+    ASSERT_EQ(book.ask_levels(), 1u);
+    ASSERT_EQ(book.best_bid(), to_price(185.0));
+    ASSERT_EQ(book.best_ask(), to_price(186.0));
+    PASS();
+}
+
+// ─── Order Book: Matching ────────────────────────────────────────────────────
+
+TEST(test_limit_buy_matches_ask) {
+    OrderBook book("AAPL");
+
+    Order sell;
+    sell.id = 1; sell.symbol = "AAPL"; sell.side = Side::SELL;
+    sell.type = OrderType::LIMIT; sell.price = to_price(185.0); sell.qty = 100;
+    book.add_order(sell);
+
+    Order buy;
+    buy.id = 2; buy.symbol = "AAPL"; buy.side = Side::BUY;
+    buy.type = OrderType::LIMIT; buy.price = to_price(185.0); buy.qty = 100;
+    auto trades = book.add_order(buy);
+
+    ASSERT_EQ(trades.size(), 1u);
+    ASSERT_EQ(trades[0].qty, 100);
+    ASSERT_EQ(trades[0].price, to_price(185.0));
+    ASSERT_EQ(book.order_count(), 0u);
+    PASS();
+}
+
+TEST(test_limit_sell_matches_bid) {
+    OrderBook book("AAPL");
+
+    Order buy;
+    buy.id = 1; buy.symbol = "AAPL"; buy.side = Side::BUY;
+    buy.type = OrderType::LIMIT; buy.price = to_price(185.0); buy.qty = 100;
+    book.add_order(buy);
+
+    Order sell;
+    sell.id = 2; sell.symbol = "AAPL"; sell.side = Side::SELL;
+    sell.type = OrderType::LIMIT; sell.price = to_price(185.0); sell.qty = 100;
+    auto trades = book.add_order(sell);
+
+    ASSERT_EQ(trades.size(), 1u);
+    ASSERT_EQ(trades[0].qty, 100);
+    ASSERT_EQ(book.order_count(), 0u);
+    PASS();
+}
+
+TEST(test_partial_fill) {
+    OrderBook book("AAPL");
+
+    Order sell;
+    sell.id = 1; sell.symbol = "AAPL"; sell.side = Side::SELL;
+    sell.type = OrderType::LIMIT; sell.price = to_price(185.0); sell.qty = 200;
+    book.add_order(sell);
+
+    Order buy;
+    buy.id = 2; buy.symbol = "AAPL"; buy.side = Side::BUY;
+    buy.type = OrderType::LIMIT; buy.price = to_price(185.0); buy.qty = 50;
+    auto trades = book.add_order(buy);
+
+    ASSERT_EQ(trades.size(), 1u);
+    ASSERT_EQ(trades[0].qty, 50);
+    ASSERT_EQ(book.order_count(), 1u);  // resting sell still has 150
+    ASSERT_EQ(book.ask_levels(), 1u);
+    PASS();
+}
+
+TEST(test_multi_level_sweep) {
+    OrderBook book("AAPL");
+
+    Order s1, s2;
+    s1.id = 1; s1.symbol = "AAPL"; s1.side = Side::SELL;
+    s1.type = OrderType::LIMIT; s1.price = to_price(185.0); s1.qty = 100;
+
+    s2.id = 2; s2.symbol = "AAPL"; s2.side = Side::SELL;
+    s2.type = OrderType::LIMIT; s2.price = to_price(186.0); s2.qty = 100;
+
+    book.add_order(s1);
+    book.add_order(s2);
+
+    // Aggressive buy sweeps both levels
+    Order buy;
+    buy.id = 3; buy.symbol = "AAPL"; buy.side = Side::BUY;
+    buy.type = OrderType::LIMIT; buy.price = to_price(187.0); buy.qty = 200;
+    auto trades = book.add_order(buy);
+
+    ASSERT_EQ(trades.size(), 2u);
+    ASSERT_EQ(trades[0].price, to_price(185.0));  // best ask first
+    ASSERT_EQ(trades[1].price, to_price(186.0));
+    ASSERT_EQ(book.order_count(), 0u);
+    ASSERT_EQ(book.ask_levels(), 0u);
+    PASS();
+}
+
+TEST(test_sell_side_multi_level_sweep) {
+    // This specifically tests the sell-side iterator fix (Bug #4)
+    OrderBook book("AAPL");
+
+    Order b1, b2, b3;
+    b1.id = 1; b1.symbol = "AAPL"; b1.side = Side::BUY;
+    b1.type = OrderType::LIMIT; b1.price = to_price(185.0); b1.qty = 100;
+
+    b2.id = 2; b2.symbol = "AAPL"; b2.side = Side::BUY;
+    b2.type = OrderType::LIMIT; b2.price = to_price(184.0); b2.qty = 100;
+
+    b3.id = 3; b3.symbol = "AAPL"; b3.side = Side::BUY;
+    b3.type = OrderType::LIMIT; b3.price = to_price(183.0); b3.qty = 100;
+
+    book.add_order(b1);
+    book.add_order(b2);
+    book.add_order(b3);
+
+    // Aggressive sell sweeps all 3 bid levels
+    Order sell;
+    sell.id = 4; sell.symbol = "AAPL"; sell.side = Side::SELL;
+    sell.type = OrderType::MARKET; sell.price = 0; sell.qty = 300;
+    auto trades = book.add_order(sell);
+
+    ASSERT_EQ(trades.size(), 3u);
+    ASSERT_EQ(trades[0].price, to_price(185.0));  // best bid first
+    ASSERT_EQ(trades[1].price, to_price(184.0));
+    ASSERT_EQ(trades[2].price, to_price(183.0));
+    ASSERT_EQ(book.bid_levels(), 0u);
+    ASSERT_EQ(book.order_count(), 0u);
+    PASS();
+}
+
+// ─── Order Types ─────────────────────────────────────────────────────────────
+
+TEST(test_market_order_no_counterparty) {
+    OrderBook book("AAPL");
+
+    Order buy;
+    buy.id = 1; buy.symbol = "AAPL"; buy.side = Side::BUY;
+    buy.type = OrderType::MARKET; buy.price = 0; buy.qty = 100;
+    auto trades = book.add_order(buy);
+
+    ASSERT_EQ(trades.size(), 0u);
+    ASSERT_EQ(buy.status, OrderStatus::CANCELLED);
+    ASSERT_EQ(book.order_count(), 0u);
+    PASS();
+}
+
+TEST(test_ioc_partial_fill) {
+    OrderBook book("AAPL");
+
+    Order sell;
+    sell.id = 1; sell.symbol = "AAPL"; sell.side = Side::SELL;
+    sell.type = OrderType::LIMIT; sell.price = to_price(185.0); sell.qty = 50;
+    book.add_order(sell);
+
+    Order buy;
+    buy.id = 2; buy.symbol = "AAPL"; buy.side = Side::BUY;
+    buy.type = OrderType::IOC; buy.price = to_price(185.0); buy.qty = 100;
+    auto trades = book.add_order(buy);
+
+    ASSERT_EQ(trades.size(), 1u);
+    ASSERT_EQ(trades[0].qty, 50);
+    ASSERT_EQ(buy.status, OrderStatus::EXPIRED);  // unfilled remainder expired
+    ASSERT_EQ(book.order_count(), 0u);  // IOC not added to book
+    PASS();
+}
+
+TEST(test_fok_rejected_insufficient_liquidity) {
+    OrderBook book("AAPL");
+
+    Order sell;
+    sell.id = 1; sell.symbol = "AAPL"; sell.side = Side::SELL;
+    sell.type = OrderType::LIMIT; sell.price = to_price(185.0); sell.qty = 50;
+    book.add_order(sell);
+
+    Order buy;
+    buy.id = 2; buy.symbol = "AAPL"; buy.side = Side::BUY;
+    buy.type = OrderType::FOK; buy.price = to_price(185.0); buy.qty = 100;
+    auto trades = book.add_order(buy);
+
+    ASSERT_EQ(trades.size(), 0u);
+    ASSERT_EQ(buy.status, OrderStatus::EXPIRED);
+    ASSERT_EQ(book.order_count(), 1u);  // resting sell untouched
+    PASS();
+}
+
+TEST(test_fok_filled_sufficient_liquidity) {
+    OrderBook book("AAPL");
+
+    Order sell;
+    sell.id = 1; sell.symbol = "AAPL"; sell.side = Side::SELL;
+    sell.type = OrderType::LIMIT; sell.price = to_price(185.0); sell.qty = 100;
+    book.add_order(sell);
+
+    Order buy;
+    buy.id = 2; buy.symbol = "AAPL"; buy.side = Side::BUY;
+    buy.type = OrderType::FOK; buy.price = to_price(185.0); buy.qty = 100;
+    auto trades = book.add_order(buy);
+
+    ASSERT_EQ(trades.size(), 1u);
+    ASSERT_EQ(trades[0].qty, 100);
+    ASSERT_EQ(book.order_count(), 0u);
+    PASS();
+}
+
+// ─── Cancel & Modify ─────────────────────────────────────────────────────────
+
+TEST(test_cancel_order) {
+    OrderBook book("AAPL");
+
+    Order buy;
+    buy.id = 1; buy.symbol = "AAPL"; buy.side = Side::BUY;
+    buy.type = OrderType::LIMIT; buy.price = to_price(185.0); buy.qty = 100;
+    book.add_order(buy);
+
+    ASSERT_TRUE(book.cancel_order(1));
+    ASSERT_EQ(book.order_count(), 0u);
+    ASSERT_EQ(book.bid_levels(), 0u);
+    ASSERT_EQ(buy.status, OrderStatus::CANCELLED);
+    PASS();
+}
+
+TEST(test_cancel_nonexistent) {
+    OrderBook book("AAPL");
+    ASSERT_TRUE(!book.cancel_order(999));
+    PASS();
+}
+
+TEST(test_modify_order) {
+    OrderBook book("AAPL");
+
+    Order buy;
+    buy.id = 1; buy.symbol = "AAPL"; buy.side = Side::BUY;
+    buy.type = OrderType::LIMIT; buy.price = to_price(185.0); buy.qty = 100;
+    book.add_order(buy);
+
+    ASSERT_TRUE(book.modify_order(1, to_price(186.0), 200));
+    ASSERT_EQ(book.best_bid(), to_price(186.0));
+    PASS();
+}
+
+// ─── Snapshot ────────────────────────────────────────────────────────────────
+
+TEST(test_snapshot_depth) {
+    OrderBook book("AAPL");
+    for (int i = 1; i <= 20; ++i) {
+        Order o;
+        o.id = i; o.symbol = "AAPL"; o.side = Side::BUY;
+        o.type = OrderType::LIMIT; o.price = to_price(185.0 - i * 0.01); o.qty = 100;
+        book.add_order(o);
+    }
+
+    auto snap = book.snapshot(5);
+    ASSERT_EQ((int)snap.bids.size(), 5);  // only top 5
+    ASSERT_TRUE(snap.bids[0].price > snap.bids[1].price);  // sorted descending
+    PASS();
+}
+
+TEST(test_snapshot_spread) {
+    OrderBook book("AAPL");
+    Order buy, sell;
+    buy.id = 1; buy.symbol = "AAPL"; buy.side = Side::BUY;
+    buy.type = OrderType::LIMIT; buy.price = to_price(185.0); buy.qty = 100;
+
+    sell.id = 2; sell.symbol = "AAPL"; sell.side = Side::SELL;
+    sell.type = OrderType::LIMIT; sell.price = to_price(185.10); sell.qty = 100;
+
+    book.add_order(buy);
+    book.add_order(sell);
+
+    auto snap = book.snapshot();
+    ASSERT_TRUE(snap.spread() > 0);
+    ASSERT_TRUE(std::abs(snap.spread() - 0.10) < 0.001);
+    PASS();
+}
+
+TEST(test_empty_book_spread) {
+    OrderBookSnapshot empty;
+    ASSERT_TRUE(empty.spread() == 0.0);
+    ASSERT_TRUE(empty.mid() == 0);
+    PASS();
+}
+
+// ─── FIFO Priority ──────────────────────────────────────────────────────────
+
+TEST(test_fifo_priority) {
+    OrderBook book("AAPL");
+
+    // Two sells at same price — first should fill first
+    Order s1, s2;
+    s1.id = 1; s1.symbol = "AAPL"; s1.side = Side::SELL;
+    s1.type = OrderType::LIMIT; s1.price = to_price(185.0); s1.qty = 100;
+
+    s2.id = 2; s2.symbol = "AAPL"; s2.side = Side::SELL;
+    s2.type = OrderType::LIMIT; s2.price = to_price(185.0); s2.qty = 100;
+
+    book.add_order(s1);
+    book.add_order(s2);
+
+    Order buy;
+    buy.id = 3; buy.symbol = "AAPL"; buy.side = Side::BUY;
+    buy.type = OrderType::LIMIT; buy.price = to_price(185.0); buy.qty = 100;
+    auto trades = book.add_order(buy);
+
+    ASSERT_EQ(trades.size(), 1u);
+    ASSERT_EQ(trades[0].sell_order_id, 1u);  // s1 filled first (FIFO)
+    ASSERT_EQ(book.order_count(), 1u);       // s2 still resting
+    PASS();
+}
+
+// ─── Main ────────────────────────────────────────────────────────────────────
+
+int main() {
+    std::cout << "\n=== Orderflow Replay Engine — Unit Tests ===\n\n";
+    // Tests run automatically via static initialization
+
+    std::cout << "\n─────────────────────────────────────────────\n";
+    std::cout << "  Passed: " << tests_passed << "\n";
+    std::cout << "  Failed: " << tests_failed << "\n";
+    std::cout << "─────────────────────────────────────────────\n\n";
+
+    return tests_failed > 0 ? 1 : 0;
+}

tests/test_risk_manager.cpp

@@ -0,0 +1,241 @@
+// tests/test_risk_manager.cpp
+// Unit tests for the risk management gateway
+
+#include "risk/risk_manager.hpp"
+#include "core/types.hpp"
+#include <cassert>
+#include <iostream>
+#include <string>
+#include <thread>
+#include <chrono>
+
+using namespace hft;
+
+static int tests_passed = 0;
+static int tests_failed = 0;
+
+#define TEST(name) \
+    void name(); \
+    struct name##_register { name##_register() { std::cout << "  " << #name << "... "; name(); } } name##_instance; \
+    void name()
+
+#define ASSERT_EQ(a, b) do { \
+    if ((a) != (b)) { \
+        std::cerr << "FAIL: " << #a << " == " << (a) << ", expected " << (b) << " at line " << __LINE__ << "\n"; \
+        ++tests_failed; return; \
+    } \
+} while(0)
+
+#define ASSERT_TRUE(x) do { \
+    if (!(x)) { \
+        std::cerr << "FAIL: " << #x << " at line " << __LINE__ << "\n"; \
+        ++tests_failed; return; \
+    } \
+} while(0)
+
+#define PASS() do { std::cout << "PASS\n"; ++tests_passed; } while(0)
+
+static Order make_order(const std::string& sym, Side side, OrderType type,
+                        double price, Quantity qty) {
+    Order o;
+    o.id = 1; o.symbol = sym; o.side = side; o.type = type;
+    o.price = to_price(price); o.qty = qty;
+    return o;
+}
+
+// ─── Basic Approval ──────────────────────────────────────────────────────────
+
+TEST(test_valid_order_approved) {
+    RiskLimits limits;
+    limits.max_order_qty = 1000;
+    limits.max_position = 10000;
+    limits.max_notional_usd = 1000000;
+    limits.max_orders_per_sec = 100;
+    RiskManager rm(limits);
+
+    auto o = make_order("AAPL", Side::BUY, OrderType::LIMIT, 185.0, 100);
+    auto result = rm.check_order(o);
+
+    ASSERT_TRUE(result.approved);
+    ASSERT_EQ(rm.orders_checked(), 1);
+    ASSERT_EQ(rm.orders_rejected(), 0);
+    PASS();
+}
+
+// ─── Rejection Tests ─────────────────────────────────────────────────────────
+
+TEST(test_reject_qty_too_large) {
+    RiskLimits limits;
+    limits.max_order_qty = 100;
+    RiskManager rm(limits);
+
+    auto o = make_order("AAPL", Side::BUY, OrderType::LIMIT, 185.0, 500);
+    auto result = rm.check_order(o);
+
+    ASSERT_TRUE(!result.approved);
+    ASSERT_EQ(result.reason, RiskRejectReason::MAX_ORDER_QTY);
+    PASS();
+}
+
+TEST(test_reject_zero_qty) {
+    RiskLimits limits;
+    RiskManager rm(limits);
+
+    auto o = make_order("AAPL", Side::BUY, OrderType::LIMIT, 185.0, 0);
+    auto result = rm.check_order(o);
+
+    ASSERT_TRUE(!result.approved);
+    ASSERT_EQ(result.reason, RiskRejectReason::INVALID_QTY);
+    PASS();
+}
+
+TEST(test_reject_negative_qty) {
+    RiskLimits limits;
+    RiskManager rm(limits);
+
+    auto o = make_order("AAPL", Side::BUY, OrderType::LIMIT, 185.0, -10);
+    auto result = rm.check_order(o);
+
+    ASSERT_TRUE(!result.approved);
+    ASSERT_EQ(result.reason, RiskRejectReason::INVALID_QTY);
+    PASS();
+}
+
+TEST(test_reject_negative_limit_price) {
+    RiskLimits limits;
+    RiskManager rm(limits);
+
+    auto o = make_order("AAPL", Side::BUY, OrderType::LIMIT, -5.0, 100);
+    auto result = rm.check_order(o);
+
+    ASSERT_TRUE(!result.approved);
+    ASSERT_EQ(result.reason, RiskRejectReason::INVALID_PRICE);
+    PASS();
+}
+
+TEST(test_reject_notional_too_large) {
+    RiskLimits limits;
+    limits.max_order_qty = 100000;
+    limits.max_notional_usd = 1000.0;  // very low limit
+    RiskManager rm(limits);
+
+    auto o = make_order("AAPL", Side::BUY, OrderType::LIMIT, 185.0, 100);
+    // notional = 185 * 100 = 18500 > 1000
+    auto result = rm.check_order(o);
+
+    ASSERT_TRUE(!result.approved);
+    ASSERT_EQ(result.reason, RiskRejectReason::MAX_NOTIONAL);
+    PASS();
+}
+
+TEST(test_reject_position_limit) {
+    RiskLimits limits;
+    limits.max_order_qty = 10000;
+    limits.max_position = 100;
+    limits.max_notional_usd = 1e9;
+    limits.max_orders_per_sec = 10000;
+    RiskManager rm(limits);
+
+    // Fill a position of 90
+    rm.on_fill("AAPL", Side::BUY, 90, 185.0);
+
+    // Try to buy 20 more → projected = 110 > max 100
+    auto o = make_order("AAPL", Side::BUY, OrderType::LIMIT, 185.0, 20);
+    auto result = rm.check_order(o);
+
+    ASSERT_TRUE(!result.approved);
+    ASSERT_EQ(result.reason, RiskRejectReason::MAX_POSITION);
+    PASS();
+}
+
+// ─── Rate Limiter ────────────────────────────────────────────────────────────
+
+TEST(test_rejected_orders_dont_count_toward_rate_limit) {
+    // This is the Bug #9 regression test
+    RiskLimits limits;
+    limits.max_order_qty = 100;
+    limits.max_orders_per_sec = 5;
+    limits.max_notional_usd = 1e9;
+    limits.max_position = 1000000;
+    RiskManager rm(limits);
+
+    // Send 10 INVALID orders (qty too large) ��� these should NOT count
+    for (int i = 0; i < 10; ++i) {
+        auto bad = make_order("AAPL", Side::BUY, OrderType::LIMIT, 185.0, 500);
+        rm.check_order(bad);
+    }
+
+    // Now send a valid order — it should still be approved
+    auto good = make_order("AAPL", Side::BUY, OrderType::LIMIT, 185.0, 50);
+    auto result = rm.check_order(good);
+
+    ASSERT_TRUE(result.approved);  // rate limit not exhausted by rejects
+    PASS();
+}
+
+// ─── Position & PnL Tracking ─────────────────────────────────────────────────
+
+TEST(test_position_after_fill) {
+    RiskLimits limits;
+    RiskManager rm(limits);
+
+    rm.on_fill("AAPL", Side::BUY, 100, 185.0);
+    auto pos = rm.get_position("AAPL");
+
+    ASSERT_EQ(pos.net_qty, 100);
+    ASSERT_TRUE(std::abs(pos.avg_price - 185.0) < 0.01);
+    PASS();
+}
+
+TEST(test_realized_pnl) {
+    RiskLimits limits;
+    RiskManager rm(limits);
+
+    // Buy 100 @ 185
+    rm.on_fill("AAPL", Side::BUY, 100, 185.0);
+    // Sell 100 @ 190 → realized = (190 - 185) * 100 = 500
+    rm.on_fill("AAPL", Side::SELL, 100, 190.0);
+
+    auto pos = rm.get_position("AAPL");
+    ASSERT_EQ(pos.net_qty, 0);
+    ASSERT_TRUE(std::abs(pos.realized_pnl - 500.0) < 0.01);
+    PASS();
+}
+
+TEST(test_unrealized_pnl) {
+    RiskLimits limits;
+    RiskManager rm(limits);
+
+    rm.on_fill("AAPL", Side::BUY, 100, 185.0);
+    rm.update_market_price("AAPL", 190.0);
+
+    auto pos = rm.get_position("AAPL");
+    // unrealized = (190 - 185) * 100 = 500
+    ASSERT_TRUE(std::abs(pos.unrealized_pnl - 500.0) < 0.01);
+    PASS();
+}
+
+TEST(test_disabled_risk_approves_all) {
+    RiskLimits limits;
+    limits.enabled = false;
+    RiskManager rm(limits);
+
+    auto o = make_order("AAPL", Side::BUY, OrderType::LIMIT, 185.0, 999999);
+    auto result = rm.check_order(o);
+
+    ASSERT_TRUE(result.approved);
+    PASS();
+}
+
+// ─── Main ────────────────────────────────────────────────────────────────────
+
+int main() {
+    std::cout << "\n=== Risk Manager — Unit Tests ===\n\n";
+
+    std::cout << "\n─────────────────────────────────────────────\n";
+    std::cout << "  Passed: " << tests_passed << "\n";
+    std::cout << "  Failed: " << tests_failed << "\n";
+    std::cout << "─────────────────────────────────────────────\n\n";
+
+    return tests_failed > 0 ? 1 : 0;
+}