Rename modules to Optiq naming and add Developers Guide

Align all component names with Euronext Optiq terminology:
- OEGatewayActor → OEGActor (Order Entry Gateway)
- OrderBookActor → MECoreActor (Matching Engine core)
- OrderBook → Book
- MarketDataActor → MDGActor (Market Data Gateway)
- FIXGatewayActor → FIXAcceptorActor

Add comprehensive English-language Developers Guide with architecture
diagrams, data flow, component reference, and build instructions.
Update README.md and process-diagram.md with new naming.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

CMakeLists.txt

@@ -50,12 +50,12 @@ include_directories(${CMAKE_SOURCE_DIR}/src)
 
 # ── Core library ────────────────────────────────────────────────────
 set(EUNEX_CORE_SOURCES
-    src/common/OrderBook.cpp
-    src/actors/OrderBookActor.cpp
-    src/actors/OEGatewayActor.cpp
-    src/actors/MarketDataActor.cpp
+    src/common/Book.cpp
+    src/actors/MECoreActor.cpp
+    src/actors/OEGActor.cpp
+    src/actors/MDGActor.cpp
     src/actors/ClearingHouseActor.cpp
-    src/actors/FIXGatewayActor.cpp
+    src/actors/FIXAcceptorActor.cpp
     src/actors/AITraderActor.cpp
     src/recovery/RecoveryProxy.cpp
     src/iaca/IacaAggregator.cpp

README.md

@@ -8,23 +8,32 @@ ported from the [StockEx](https://github.com/Bonum/StockEx) Python prototype.
 ```
 StockEx (Python/Kafka)              EuNEx (C++/Simplx)                 Optiq (Production)
 ─────────────────────               ──────────────────                  ──────────────────
-fix_oeg_server.py        →   OEGatewayActor           →   OEActor
+fix_oeg_server.py        →   OEGActor                 →   OEActor
   Kafka 'orders' topic   →     Event::Pipe            →     Simplx Event::Pipe
-matcher.py               →   OrderBookActor           →   LogicalCoreActor + Book
-  match_order()          →     OrderBook::newOrder()   →     RecoveryCause → IACA Cause → forwardToBook
-  handle_cancel()        →     OrderBook::cancelOrder()→     CancelOrderData
-  handle_amend()         →     OrderBook::modifyOrder()→     ModifyOrderData
+matcher.py               →   MECoreActor              →   LogicalCoreActor + Book
+  match_order()          →     Book::newOrder()        →     RecoveryCause → IACA Cause → forwardToBook
+  handle_cancel()        →     Book::cancelOrder()     →     CancelOrderData
+  handle_amend()         →     Book::modifyOrder()     →     ModifyOrderData
   Kafka 'trades' topic   →     TradeEvent via Pipe     →     IACA fragment chain
-dashboard.py (SSE)       →   MarketDataActor           →   MDLimitLogicalCoreHandler
+dashboard.py (SSE)       →   MDGActor                  →   MDLimitLogicalCoreHandler
   /orderbook/<sym>       →     BookUpdateEvent         →     PublishLimitUpdateRequest
   /trades                →     TradeEvent              →     IACA → IA SBE message
-database.py (SQLite)     →   SQLite persistence        →   RecoveryProxy → Kafka
-  save_trade()           →     dashboard/database.py   →   PersistenceAgent → Kafka produce
-fix_oeg_server.py        →   fix_gateway/fix_server.py →   FIX 4.4 OEG Acceptor
+database.py (SQLite)     →   RecoveryProxy (memory)    →   RecoveryProxy → Kafka
+  save_trade()           →     FragmentStore::append() →   PersistenceAgent → Kafka produce
+fix_oeg_server.py        →   FIXAcceptorActor          →   FIX 4.4 OEG Acceptor
   NewOrderSingle         →     35=D handling           →     Optiq FIX gateway
   ExecutionReport        →     35=8 response           →     Execution reports
-ch_ai_trader.py          →   clearing_house/           →   Clearing House members
-  AI strategies          →     momentum/mean_revert    →     Trading obligations
+ch_ai_trader.py          →   ClearingHouseActor        →   Clearing House (PTB path)
+  AI strategies          →   AITraderActor             →   Trading obligations
+```
+
+## Actor Topology (v0.4)
+
+```
+ Core 0: OEGActor + FIXAcceptorActor     ← Order entry & FIX protocol
+ Core 1: MECoreActor (per symbol)         ← Matching engine (Book)
+ Core 2: MDGActor                         ← Market data snapshots
+ Core 3: ClearingHouseActor + AITrader    ← Post-trade & AI members
 ```
 
 ## Service Architecture
@@ -44,19 +53,18 @@ ch_ai_trader.py          →   clearing_house/           →   Clearing House me
 │ Trade Charts    │ │ Leaderboard     │ │ NewOrder/Cancel  │
 │ OHLCV History   │ │ Portfolios      │ │ Amend/ExecRpt   │
 │ SQLite DB       │ │ Settlements     │ │                  │
-│ SSE Streaming   │ │ SQLite DB       │ │                  │
-└────────┬────────┘ └��──────┬──────────┘ └────────┬────────┘
-         │                  │                      │
-         │    HTTP REST     │    HTTP REST          │
-         ◄──────────────────┘◄─────────────────────┘
-         │
-         ▼
-┌─────────────────────────────┐
-│    C++ Matching Engine      │
-│    (eunex_me)               │
-│    Multi-threaded actors    │
-│    Price-time priority      │
-└─────────────────────────────┘
+│ SSE Streaming   │ │                 │ │                  │
+└────────┬────────┘ └────────┬────────┘ └────────┬────────┘
+         │                   │                    │
+         └───────────────────┴────────────────────┘
+                             │
+                             ▼
+               ┌─────────────────────────────┐
+               │    C++ Matching Engine      │
+               │    (eunex_me)               │
+               │    Multi-threaded actors    │
+               │    Price-time priority      │
+               └─────────────────────────────┘
 ```
 
 ## Quick Start (Linux)
@@ -95,31 +103,30 @@ docker compose up --build
 ## Build C++ Engine
 
 ```bash
-mkdir build && cd build
-cmake ..
-cmake --build . --config Release
+cmake -B build -DEUNEX_BUILD_TESTS=ON
+cmake --build build --config Release
 
-# Run matching engine demo
-./eunex_me
+# Run matching engine
+./build/Release/eunex_me
 
-# Run all tests (26 tests)
-ctest
+# Run all tests (6 suites)
+cd build && ctest -C Release
 ```
 
 ## With Kafka Persistence
 
 ```bash
-cmake -DEUNEX_USE_KAFKA=ON ..
-cmake --build . --config Release
+cmake -B build -DEUNEX_USE_KAFKA=ON
+cmake --build build --config Release
 ```
 
 ## FIX Gateway
 
+The C++ engine includes a built-in FIX 4.4 acceptor on TCP port 9001.
+A Python FIX gateway is also available:
+
 ```bash
-# Start FIX server (requires dashboard running)
 python fix_gateway/fix_server.py
-
-# Test with built-in client
 python fix_gateway/fix_server.py test
 ```
 
@@ -128,49 +135,32 @@ OrderCancelReplaceRequest (35=G), ExecutionReport (35=8).
 
 ## Clearing House
 
-```bash
-# Start clearing house (requires dashboard running)
-python clearing_house/app.py
-```
+10 AI trading members (MBR01-MBR10) with 3 strategies:
+- **Momentum**: follow price trends
+- **Mean Reversion**: fade price moves
+- **Random**: noise trading
 
-Features:
-- 10 AI trading members (MBR01-MBR10) with 3 strategies
-- Strategies: momentum, mean_reversion, random
-- Member portal with login, portfolio, order submission
-- Leaderboard with capital, holdings, P&L
-- Daily trading obligation (min 20 securities)
-- EOD settlement
-
-## Web Dashboard
-
-Features:
-- Real-time order book with bid/ask depth bars
-- OHLCV price charts (1H, 8H, 1D, 1W) via Chart.js
-- Order entry with Limit/Market, TIF (Day/GTC/IOC/FOK)
-- Order amend and cancel
-- Trade blotter with history
-- Market snapshots (BBO, last price, volume)
-- Clearing House leaderboard integration
-- Session controls (Start/Suspend/Resume/End Day)
-- SSE real-time streaming
-- SQLite persistence for orders, trades, OHLCV
-- EQU (Cash/Equities) and EQD (Derivatives) segments
+Features: capital tracking, holdings per symbol, P&L, leaderboard.
 
 ## Project Structure
 
 ```
 EuNEx/
 ├── src/                                # C++ matching engine
-│   ├── main.cpp                        # Entry point
+│   ├── main.cpp                        # Entry point, actor wiring
 │   ├── engine/SimplxShim.hpp           # Multi-threaded actor engine
 │   ├── common/
 │   │   ├── Types.hpp                   # Price, Order, Trade, enums
-│   │   ├── OrderBook.hpp/cpp           # Price-time priority matching
+│   │   └── Book.hpp/cpp               # Price-time priority matching
 │   ├── actors/
 │   │   ├── Events.hpp                  # Inter-actor event types
-│   │   ├── OrderBookActor.hpp/cpp      # Matching engine actor
-│   │   ├── OEGatewayActor.hpp/cpp      # Order entry gateway
-│   │   └── MarketDataActor.hpp/cpp     # Market data publisher
+│   │   ├── OEGActor.hpp/cpp           # Order Entry Gateway
+│   │   ├── MECoreActor.hpp/cpp        # Matching Engine core (per symbol)
+│   │   ├── MDGActor.hpp/cpp           # Market Data Gateway
+│   │   ├── FIXAcceptorActor.hpp/cpp   # FIX 4.4 TCP acceptor
+│   │   ├── ClearingHouseActor.hpp/cpp # Trade clearing & member positions
+│   │   └── AITraderActor.hpp/cpp      # Automated trading members
+│   ├── net/SocketCompat.hpp           # Cross-platform socket abstraction
 │   ├── persistence/
 │   │   ├── PersistenceStore.hpp        # Abstract store + InMemoryStore
 │   │   └── KafkaStore.hpp              # Kafka persistence (optional)
@@ -183,34 +173,44 @@ EuNEx/
 │   ├── database.py                     # SQLite (orders, trades, OHLCV)
 │   └── templates/index.html            # Trading UI with Chart.js
 ├── fix_gateway/
-│   └── fix_server.py                   # FIX 4.4 TCP acceptor
+│   └── fix_server.py                   # Python FIX 4.4 TCP acceptor
 ├── clearing_house/
 │   ├── app.py                          # Flask CH portal + API
-│   ├── ch_database.py                  # SQLite (members, holdings, settlements)
+│   ├── ch_database.py                  # SQLite (members, holdings)
 │   ├── ch_ai_trader.py                 # AI trading strategies
-│   └── templates/                      # CH web UI (login, dashboard, portfolio)
-├── shared/
-│   └── config.py                       # Centralized configuration
+│   └── templates/                      # CH web UI
+├── shared/config.py                    # Centralized configuration
 ├── docker/
 │   ├── docker-compose.yml              # Kafka + EuNEx (all services)
-���   ├── Dockerfile                      # Multi-stage Linux build
+│   ├── Dockerfile                      # Multi-stage Linux build
 │   └── nginx.conf                      # Reverse proxy configuration
-├── run.sh                              # Linux startup script
 ├── tests/
-│   ├── test_orderbook.cpp              # OrderBook unit tests (14)
-│   ├── test_matching_engine.cpp        # Actor integration tests (6)
-│   └── test_threaded_engine.cpp        # Multi-threaded engine tests (6)
+│   ├── test_orderbook.cpp              # Book unit tests (26 cases)
+│   ├── test_matching_engine.cpp        # ME integration tests
+│   ├── test_threaded_engine.cpp        # Multi-threaded engine tests
+│   ├── test_clearing_house.cpp         # Clearing house tests (7 cases)
+│   ├── test_fix_gateway.cpp            # FIX gateway tests (5 cases)
+│   └── test_ai_trader.cpp             # AI trader tests (6 cases)
 ├── examples/
 │   ├── ping_pong.cpp                   # Actor basics tutorial
 │   └── simple_match.cpp                # Matching with Recovery + IACA
-└── docs/process-diagram.md             # Architecture diagrams
+└── docs/
+    ├── developers-guide.md             # Detailed developers guide
+    └── process-diagram.md              # Architecture diagrams
 ```
 
+## Documentation
+
+- **[Developers Guide](docs/developers-guide.md)** — Detailed architecture, data flow, component reference
+- **[Process Diagram](docs/process-diagram.md)** — Optiq architecture diagrams and roadmap
+
 ## Next Steps
 
-1. ~~Add real Simplx integration~~ ✓ Multi-threaded actor engine with mailbox queues
+1. ~~Multi-threaded actor engine~~ ✓ SimplxShim with mailbox queues
 2. ~~Kafka persistence~~ ✓ KafkaStore + Docker Compose (KRaft mode)
-3. **SBE encoding** — replace event structs with SBE-encoded messages
-4. ~~FIX gateway~~ ✓ Pure Python FIX 4.4 TCP acceptor
-5. **Master/Mirror failover** — implement full Recovery replay on Mirror node
-6. ~~Clearing House actors~~ ✓ AI trading members with 3 strategies + portal
+3. ~~FIX gateway~~ ✓ C++ FIXAcceptorActor + Python fallback
+4. ~~Clearing House~~ ✓ ClearingHouseActor + AITraderActor
+5. **SBE encoding** — replace event structs with SBE-encoded messages
+6. **Master/Mirror failover** — implement full Recovery replay on Mirror node
+7. **Trading phases** — pre-open, uncrossing, continuous, close, TAL
+8. **Additional order types** — Stop, Pegged, Mid-Point, Iceberg

docs/developers-guide.md

@@ -0,0 +1,889 @@
+# EuNEx Developers Guide
+
+**Version 0.4.0** | Euronext Optiq-Modeled Exchange Simulator
+
+---
+
+## Table of Contents
+
+1. [Overview](#1-overview)
+2. [Architecture](#2-architecture)
+3. [Optiq Naming Alignment](#3-optiq-naming-alignment)
+4. [Actor Topology](#4-actor-topology)
+5. [Data Flow](#5-data-flow)
+6. [Core Components](#6-core-components)
+7. [Event System](#7-event-system)
+8. [Order Book & Matching](#8-order-book--matching)
+9. [Recovery & IACA](#9-recovery--iaca)
+10. [FIX Protocol Gateway](#10-fix-protocol-gateway)
+11. [Clearing House](#11-clearing-house)
+12. [AI Trading Members](#12-ai-trading-members)
+13. [Project Structure](#13-project-structure)
+14. [Build & Test](#14-build--test)
+15. [Configuration](#15-configuration)
+16. [Extending EuNEx](#16-extending-eunex)
+
+---
+
+## 1. Overview
+
+EuNEx (Euronext Exchange Simulator) is a C++20 actor-based matching engine that mirrors the Euronext Optiq production architecture. It implements the full order lifecycle: entry, validation, matching, market data dissemination, trade clearing, and FIX protocol connectivity.
+
+```
+  ┌─────────────────────────────────────────────────────────────────────┐
+  │                         EuNEx v0.4.0                                │
+  │                                                                     │
+  │   FIX 4.4 Clients ──► OEG ──► ME (per symbol) ──► MDG             │
+  │                         │                    │                       │
+  │                         ◄── Exec Reports ◄───┘                      │
+  │                                              │                      │
+  │                                         Clearing House              │
+  │                                              │                      │
+  │                                         AI Traders (x10)            │
+  └─────────────────────────────────────────────────────────────────────┘
+```
+
+**Key design principles:**
+- Actor-per-core isolation (no shared mutable state in the hot path)
+- Lock-free `Event::Pipe` for cross-actor communication
+- Fixed-point pricing (8 decimal places, `PRICE_SCALE = 10^8`)
+- Price-time priority matching with multi-level sweep
+- Master/Mirror recovery gating for high availability
+
+---
+
+## 2. Architecture
+
+### High-Level System Diagram
+
+```
+ ┌─────────────────────────────────────────────────────────────────────────────┐
+ │                           EXTERNAL CLIENTS                                  │
+ │                      FIX 4.4 / Direct API / Python Bridge                   │
+ └─────────────────────────┬───────────────────────────────┬───────────────────┘
+                           │                               │
+                    TCP :9001                        Direct API
+                           │                               │
+ ╔═════════════════════════╪═══════════════════════════════╪═══════════════════╗
+ ║  CORE 0 — Gateway                                                          ║
+ ║  ┌──────────────────────┴───┐    ┌──────────────────────┴───┐              ║
+ ║  │   FIXAcceptorActor       │    │     OEGActor             │              ║
+ ║  │                          │───►│                          │              ║
+ ║  │  • TCP accept loop       │    │  • Session validation    │              ║
+ ║  │  • FIX 4.4 parse/build   │    │  • Symbol routing        │              ║
+ ║  │  • Logon/Logout/HB       │    │  • Exec report fanout    │              ║
+ ║  │  • D, F, G → Events      │    │  • Cancel, Modify        │              ║
+ ║  └──────────────────────────┘    └──────────┬───────────────┘              ║
+ ╚═════════════════════════════════════════════╪═══════════════════════════════╝
+                                               │ NewOrderEvent
+                                               │ CancelOrderEvent
+                                               │ ModifyOrderEvent
+                                               │ (Event::Pipe)
+                                               ▼
+ ╔═════════════════════════════════════════════════════════════════════════════╗
+ ║  CORE 1 — Matching Engine (one MECoreActor per symbol)                     ║
+ ║                                                                             ║
+ ║  ┌───────────────┐ ┌───────────────┐ ┌───────────────┐ ┌───────────────┐   ║
+ ║  │ MECoreActor   │ │ MECoreActor   │ │ MECoreActor   │ │ MECoreActor   │   ║
+ ║  │ AAPL (sym=1)  │ │ MSFT (sym=2)  │ │ GOOGL (sym=3) │ │ EURO50 (sym=4)│   ║
+ ║  │               │ │               │ │               │ │               │   ║
+ ║  │  ┌─────────┐  │ │  ┌─────────┐  │ │  ┌─────────┐  │ │  ┌─────────┐  │   ║
+ ║  │  │  Book   │  │ │  │  Book   │  │ │  │  Book   │  │ │  │  Book   │  │   ║
+ ║  │  │ (bids)  │  │ │  │ (bids)  │  │ │  │ (bids)  │  │ │  │ (bids)  │  │   ║
+ ║  │  │ (asks)  │  │ │  │ (asks)  │  │ │  │ (asks)  │  │ │  │ (asks)  │  │   ║
+ ║  │  └─────────┘  │ │  └─────────┘  │ │  └─────────┘  │ │  └─────────┘  │   ║
+ ║  └───────┬───────┘ └───────┬───────┘ └───────┬───────┘ └───────┬───────┘   ║
+ ║          │                 │                 │                 │             ║
+ ║          └────────┬────────┴────────┬────────┴────────┬────────┘             ║
+ ╚═══════════════════╪════════════════╪════════════════╪═══════════════════════╝
+                     │                │                │
+            ExecReport│       TradeEvent│      BookUpdate│
+            (→ OEG)   │       (→ MDG)   │      (→ MDG)   │
+                     │                │                │
+ ╔═══════════════════╪════════════════╪════════════════╪═══════════════════════╗
+ ║  CORE 2 — Market Data             ▼                ▼                        ║
+ ║  ┌─────────────────────────────────────────────────────────────────────┐     ║
+ ║  │  MDGActor                                                           │     ║
+ ║  │                                                                     │     ║
+ ║  │  • BBO snapshots per symbol (bestBid, bestAsk, depths)             │     ║
+ ║  │  • Recent trade history (last 200 trades)                          │     ║
+ ║  │  • Trade count, volume, last price per symbol                      │     ║
+ ║  │  • Thread-safe reads for Python dashboard bridge                   │     ║
+ ║  └─────────────────────────────────────────────────────────────────────┘     ║
+ ╚═════════════════════════════════════════════════════════════════════════════╝
+                                               │
+                                          TradeEvent
+                                          (→ Clearing)
+                                               │
+ ╔═════════════════════════════════════════════╪═══════════════════════════════╗
+ ║  CORE 3 — Post-Trade & AI                  ▼                                ║
+ ║  ┌─────────────────────────────┐    ┌─────────────────────────────┐         ║
+ ║  │  ClearingHouseActor         │    │  AITraderActor              │         ║
+ ║  │                             │    │                             │         ║
+ ║  │  • Session → Member map     │    │  • 10 members (MBR01-10)   │         ║
+ ║  │  • Capital tracking         │    │  • 3 strategies:           │         ║
+ ║  │  • Holdings per symbol      │    │    momentum, mean_revert,  │         ║
+ ║  │  • P&L calculation          │    │    random                  │         ║
+ ║  │  • Leaderboard (sorted)     │    │  • Periodic order bursts   │         ║
+ ║  │  • Thread-safe for bridge   │    │  • BBO + price history     │         ║
+ ║  └─────────────────────────────┘    └──────────────┬──────────────┘         ║
+ ║                                                     │                       ║
+ ║                                              NewOrderEvent                  ║
+ ║                                              (→ OEG → ME)                   ║
+ ╚═════════════════════════════════════════════════════════════════════════════╝
+```
+
+---
+
+## 3. Optiq Naming Alignment
+
+EuNEx components are named to match Euronext Optiq production terminology:
+
+```
+ Optiq Production                EuNEx Class             File
+ ═══════════════════════         ════════════════════     ═══════════════════════════
+ OEActor (OE Gateway)      ───► OEGActor                 src/actors/OEGActor.hpp
+ LogicalCoreActor + Book   ───► MECoreActor              src/actors/MECoreActor.hpp
+ Book (order book engine)  ───► Book                     src/common/Book.hpp
+ MDLimitLogicalCoreHandler ───► MDGActor                 src/actors/MDGActor.hpp
+ OEG FIX Gateway           ───► FIXAcceptorActor         src/actors/FIXAcceptorActor.hpp
+ Clearing House (PTB path) ───► ClearingHouseActor       src/actors/ClearingHouseActor.hpp
+ Member Trading Bots       ───► AITraderActor            src/actors/AITraderActor.hpp
+ RecoveryProxy             ───► RecoveryProxy            src/recovery/RecoveryProxy.hpp
+ IacaAggregatorActor       ───► IacaAggregator           src/iaca/IacaAggregator.hpp
+```
+
+**Why these names?**
+- **OEG** = Order Entry Gateway (the Optiq front-end for all order flow)
+- **ME** = Matching Engine (the core `Book` + `LogicalCoreActor` in Optiq)
+- **MDG** = Market Data Gateway (publishes BBO, trades, depth to consumers)
+- **FIXAcceptor** = Optiq's FIX protocol acceptor component within OEG
+
+---
+
+## 4. Actor Topology
+
+### Core Affinity Layout
+
+```
+ ┌──────────────────────────────────────────────────────────────────────────────┐
+ │                                                                              │
+ │  ┌─ CPU Core 0 ─────────────────┐    ┌─ CPU Core 1 ────────────────────┐   │
+ │  │                               │    │                                 │   │
+ │  │  OEGActor                     │    │  MECoreActor (AAPL, sym=1)     │   │
+ │  │   • Symbol → Book routing     │    │  MECoreActor (MSFT, sym=2)     │   │
+ │  │   • Exec report fanout        │    │  MECoreActor (GOOGL, sym=3)    │   │
+ │  │                               │    │  MECoreActor (EURO50, sym=4)   │   │
+ │  │  FIXAcceptorActor             │    │                                 │   │
+ │  │   • TCP :9001                 │    │  Each owns a Book instance     │   │
+ │  │   • FIX 4.4 protocol         │    │  Single-threaded per actor     │   │
+ │  │                               │    │  No locks in matching path     │   │
+ │  └───────────────────────────────┘    └─────────────────────────────────┘   │
+ │                                                                              │
+ │  ┌─ CPU Core 2 ─────────────────┐    ┌─ CPU Core 3 ────────────────────┐   │
+ │  │                               │    │                                 │   │
+ │  │  MDGActor                     │    │  ClearingHouseActor            │   │
+ │  │   • BBO per symbol            │    │   • 10 members, capital, P&L   │   │
+ │  │   • Trade history             │    │   • Session → Member mapping   │   │
+ │  │   • Snapshot queries          │    │                                 │   │
+ │  │                               │    │  AITraderActor                  │   │
+ │  │                               │    │   • 10 AI members              │   │
+ │  │                               │    │   • Momentum / MeanRev / Rand  │   │
+ │  └───────────────────────────────┘    └─────────────────────────────────┘   │
+ │                                                                              │
+ └──────────────────────────────────────────────────────────────────────────────┘
+```
+
+### Event::Pipe Connections
+
+```
+ FIXAcceptorActor ──NewOrderEvent──────► OEGActor ──NewOrderEvent──► MECoreActor
+                                                  ──CancelOrderEvent──►
+                                                  ──ModifyOrderEvent──►
+
+ MECoreActor ──ExecReportEvent──► OEGActor ──ExecReportEvent──► FIXAcceptorActor
+                                           ──ExecReportEvent──► AITraderActor
+
+ MECoreActor ──TradeEvent──────► MDGActor
+             ──BookUpdateEvent─► MDGActor
+             ──TradeEvent──────► ClearingHouseActor
+
+ AITraderActor ──NewOrderEvent──► OEGActor (via pipe)
+```
+
+---
+
+## 5. Data Flow
+
+### Order Lifecycle (New Limit Order)
+
+```
+ ┌──────────┐    FIX 35=D     ┌──────────────────┐   NewOrderEvent    ┌──────────────┐
+ │  Client  │ ──────────────► │ FIXAcceptorActor  │ ────────────────► │   OEGActor   │
+ │ (FIX)    │                 │ parse FIX tags    │                   │ route by sym │
+ └──────────┘                 │ map symbol string │                   └──────┬───────┘
+                              │ to SymbolIndex_t  │                          │
+                              └───────────────────┘                          │
+                                                                    NewOrderEvent
+                                                                    (Event::Pipe)
+                                                                             │
+                                                                             ▼
+                              ┌────────────────────────────────────────────────────┐
+                              │                  MECoreActor                        │
+                              │                                                    │
+                              │   1. RecoveryProxy.cause() — persist fragment      │
+                              │   2. Book.newOrder() — price-time matching         │
+                              │   3. For each fill:                                │
+                              │      a. Trade generated (buyer + seller session)   │
+                              │      b. TradeEvent → MDGActor                     │
+                              │      c. TradeEvent → ClearingHouseActor           │
+                              │   4. ExecReportEvent → OEGActor (ack/fill/reject) │
+                              │   5. BookUpdateEvent → MDGActor (new BBO)         │
+                              │   6. IACA fragments → IacaAggregator              │
+                              └────────────────────────────────────────────────────┘
+                                         │                          │
+                                ExecReportEvent              TradeEvent
+                                         │                          │
+                                         ▼                          ▼
+                              ┌───────────────────┐    ┌──────────────────────┐
+                              │    OEGActor        │    │  ClearingHouseActor  │
+                              │ fanout to:         │    │  • map session→member│
+                              │  • FIXAcceptor     │    │  • update capital    │
+                              │  • AITrader        │    │  • update holdings   │
+                              └────────┬──────────┘    └──────────────────────┘
+                                       │
+                              FIX 35=8 (ExecReport)
+                                       │
+                                       ▼
+                              ┌───────────────────┐
+                              │     Client         │
+                              │  receives fill     │
+                              └───────────────────┘
+```
+
+### Market Data Flow
+
+```
+ MECoreActor ──TradeEvent──────────────► MDGActor
+             ──BookUpdateEvent──────────►    │
+                                              │
+                                              ▼
+                                     ┌──────────────────────┐
+                                     │  MarketDataSnapshot   │
+                                     │  per SymbolIndex_t:   │
+                                     │                       │
+                                     │  • bestBid, bestAsk  │
+                                     │  • lastTradePrice    │
+                                     │  • lastTradeQty      │
+                                     │  • totalBidQty       │
+                                     │  • totalAskQty       │
+                                     │  • tradeCount        │
+                                     │  • updateTime (ns)   │
+                                     │                       │
+                                     │  recentTrades[]      │
+                                     │  (last 200 trades)   │
+                                     └──────────────────────┘
+                                              │
+                                     getSnapshot() / getRecentTrades()
+                                     (thread-safe, read by Python bridge)
+```
+
+---
+
+## 6. Core Components
+
+### 6.1 SimplxShim — Actor Framework (`src/engine/SimplxShim.hpp`)
+
+The actor engine emulates the [Tredzone Simplx](https://github.com/Tredzone/simplx) framework API:
+
+| Simplx Concept        | EuNEx Implementation                          |
+|----------------------|-----------------------------------------------|
+| `Actor`              | Base class with event handlers, mailbox        |
+| `Event::Pipe`        | Lock-free cross-actor channel                  |
+| `ActorId`            | `{id: uint64, coreId: uint8}`                 |
+| `Engine`             | Multi-threaded scheduler with core affinity    |
+| `Callback`           | Timer-like periodic invocation                 |
+| `AsyncService`       | Service locator pattern                        |
+
+**Two operating modes:**
+- **Synchronous** (tests): events delivered inline, single thread
+- **Threaded** (`Engine::runFor`): per-core OS threads, mailbox queues
+
+```
+ Synchronous Mode (unit tests)          Threaded Mode (Engine::runFor)
+ ═══════════════════════════            ═══════════════════════════════
+
+ ActorA.pipe.push<Event>()              ActorA.pipe.push<Event>()
+       │                                       │
+       ▼                                       ▼
+ ActorB.onEvent() ← inline              Mailbox[coreB].enqueue(λ)
+                                               │
+                                        Core B thread:
+                                         mbox.waitAndDrain()
+                                               │
+                                               ▼
+                                        ActorB.onEvent()
+```
+
+### 6.2 Types (`src/common/Types.hpp`)
+
+```cpp
+Price_t       = int64_t     // Fixed-point, PRICE_SCALE = 100'000'000
+Quantity_t    = uint64_t
+OrderId_t     = uint64_t    // Exchange-assigned order ID
+ClOrdId_t     = uint64_t    // Client order ID
+SymbolIndex_t = uint32_t    // Instrument identifier
+TradeId_t     = uint64_t
+SessionId_t   = uint16_t    // Client session identifier
+MemberId_t    = uint16_t    // Clearing member identifier
+Timestamp_ns  = uint64_t    // Nanosecond timestamp
+```
+
+**Price conversion:**
+```cpp
+Price_t px = toFixedPrice(150.25);  // → 15'025'000'000
+double  d  = toDouble(px);          // → 150.25
+```
+
+### 6.3 Order & Trade Structs
+
+```
+ Order (88 bytes, packed)                Trade (72 bytes, packed)
+ ═══════════════════════                 ═══════════════════════
+ orderId      : uint64                   tradeId       : uint64
+ clOrdId      : uint64                   symbolIdx     : uint32
+ symbolIdx    : uint32                   price         : int64
+ side         : uint8  (Buy=1,Sell=2)    quantity      : uint64
+ ordType      : uint8  (Market=1,Lim=2)  buyOrderId    : uint64
+ tif          : uint8  (Day/GTC/IOC/FOK) sellOrderId   : uint64
+ price        : int64                    buyClOrdId    : uint64
+ quantity     : uint64                   sellClOrdId   : uint64
+ remainingQty : uint64                   matchTime     : uint64
+ entryTime    : uint64                   buySessionId  : uint16
+ sessionId    : uint16                   sellSessionId : uint16
+ status       : uint8
+```
+
+---
+
+## 7. Event System
+
+Events flow between actors via `Event::Pipe`. Each event struct inherits `tredzone::Actor::Event`:
+
+```
+ ┌─────────────────────────────────────────────────────────────────────────────┐
+ │                           EVENT CATALOG                                     │
+ │                                                                             │
+ │  NewOrderEvent         OEG → ME       New order submission                 │
+ │  CancelOrderEvent      OEG → ME       Cancel resting order                │
+ │  ModifyOrderEvent      OEG → ME       Modify price/qty (cancel-replace)   │
+ │  ExecReportEvent       ME → OEG       Ack, fill, partial, reject          │
+ │  TradeEvent            ME → MDG/CH    Trade execution                      │
+ │  BookUpdateEvent       ME → MDG/AI    BBO + depth snapshot                │
+ │  RecoveryFragmentEvent ME → Persist   Recovery persistence                │
+ │                                                                             │
+ │  Direction Key:                                                             │
+ │  OEG = OEGActor       ME = MECoreActor     MDG = MDGActor                │
+ │  CH = ClearingHouse    AI = AITraderActor                                  │
+ └─────────────────────────────────────────────────────────────────────────────┘
+```
+
+### Event::Pipe Usage Pattern
+
+```cpp
+// In MECoreActor constructor:
+oePipe_ = Event::Pipe(*this, oeGatewayId);   // pipe to OEG
+mdPipe_ = Event::Pipe(*this, marketDataId);   // pipe to MDG
+
+// Pushing an event (lock-free, zero-copy in same-core mode):
+oePipe_.push<ExecReportEvent>(report, sessionId);
+mdPipe_.push<TradeEvent>(trade);
+```
+
+---
+
+## 8. Order Book & Matching
+
+### Book (`src/common/Book.hpp`)
+
+The `Book` class implements price-time priority matching:
+
+```
+ BIDS (sorted descending)              ASKS (sorted ascending)
+ ════════════════════════              ════════════════════════
+
+ Price    │ Orders (FIFO)              Price    │ Orders (FIFO)
+ ─────────┼──────────────              ─────────┼──────────────
+ 155.00   │ [100] [50]                 157.00   │ [200]
+ 154.50   │ [200]                      158.00   │ [100] [150]
+ 154.00   │ [75] [100] [25]            159.00   │ [300]
+ 153.00   │ [500]                      160.00   │ [50]
+
+ std::map<Price_t,                     std::map<Price_t,
+   vector<Order>,                        vector<Order>,
+   std::greater<>>                       std::less<>>
+```
+
+**Matching algorithm:**
+
+```
+ Incoming BUY @ 158.00, qty=250
+ ──────────────────────────────
+
+ Step 1: Match vs best ask 157.00 (qty=200)
+         → Trade: 200 @ 157.00
+         → Ask level 157.00 exhausted
+
+ Step 2: Match vs next ask 158.00 (qty=100 + 150)
+         → Trade: 50 @ 158.00 (from first order, partial)
+         → Remaining incoming qty = 0 → DONE
+
+ Step 3: Incoming fully filled
+         → ExecReport: status=Filled, filledQty=250
+```
+
+**Order types:**
+- `Limit`: rests on book if no match; price-time priority
+- `Market`: sweeps all levels; never rests (IOC behavior)
+
+**Time-in-force:**
+- `Day`: rests until end of session
+- `IOC`: fill what's available, cancel remainder
+- `FOK`: fill all or reject entirely
+
+### MECoreActor (`src/actors/MECoreActor.hpp`)
+
+```
+ NewOrderEvent ──► MECoreActor.onEvent()
+                        │
+                        ├── RecoveryProxy.cause(persistenceId, order, λ)
+                        │     └── Fragment persisted to store
+                        │
+                        ├── book_.newOrder(order, onTrade, onExec)
+                        │     ├── matchBuy() / matchSell()
+                        │     │     └── for each fill: onTrade(trade)
+                        │     └── onExec(report)
+                        │
+                        ├── oePipe_.push<ExecReportEvent>(report, session)
+                        ├── mdPipe_.push<TradeEvent>(trade)         [per fill]
+                        ├── mdPipe_.push<BookUpdateEvent>(snapshot)  [if book changed]
+                        └── chPipe_.push<TradeEvent>(trade)         [per fill, if CH wired]
+```
+
+---
+
+## 9. Recovery & IACA
+
+### RecoveryProxy (`src/recovery/RecoveryProxy.hpp`)
+
+```
+ ┌──────────────────────────────────────────────────────────────────────┐
+ │  RecoveryProxy (per MECoreActor)                                     │
+ │                                                                      │
+ │  cause(persistenceId, payload, callback)                             │
+ │    → persist Fragment to FragmentStore                               │
+ │    → callback returns nextCount (# children expected)               │
+ │    → always executes (Master AND Mirror)                            │
+ │                                                                      │
+ │  effect(fn, args...)                                                 │
+ │    → executes fn only on MASTER                                     │
+ │    → side effects: send ExecReports, publish trades                 │
+ │                                                                      │
+ │  recoveryEffect(fn, args...)                                         │
+ │    → executes fn only on MIRROR (during failover replay)            │
+ │                                                                      │
+ │  ┌────────────────┐            ┌────────────────┐                   │
+ │  │  MASTER         │            │  MIRROR         │                   │
+ │  │  cause()  ✓     │  ◄──────►  │  cause()  ✓     │                   │
+ │  │  effect() ✓     │  Fragment   │  effect() ✗     │                   │
+ │  │  recEff() ✗     │  Store      │  recEff() ✓     │                   │
+ │  └────────────────┘  (shared)   └────────────────┘                   │
+ └──────────────────────────────────────────────────────────────────────┘
+```
+
+### IACA Fragment Chains (`src/iaca/IacaAggregator.hpp`)
+
+```
+ Chain Completion Algorithm:
+ ══════════════════════════
+
+ Fragment 1 (ROOT: NEW_ORDER_BUY)       nextCount = 2
+     ├── Fragment 2 (ACK_DATA)          nextCount = 0
+     └── Fragment 3 (TRADE_DATA)        nextCount = 0
+
+ Completion check:
+   sum(nextCount) = 2 + 0 + 0 = 2
+   total fragments = 3
+   complete when: sum == total - 1     →  2 == 3 - 1  ✓
+
+ On completion:
+   → NewOrderHandler fires
+   → Generates IA SBE message (future: IDS/PTB/SATURN)
+```
+
+---
+
+## 10. FIX Protocol Gateway
+
+### FIXAcceptorActor (`src/actors/FIXAcceptorActor.hpp`)
+
+```
+ ┌──────────────────────────────────────────────────────────────────────────┐
+ │  FIXAcceptorActor (TCP :9001)                                            │
+ │                                                                          │
+ │  ┌─ Accept Thread ──────────────────────────────────────────────────┐    │
+ │  │  while(running):                                                  │    │
+ │  │    sock = accept(listenSock)                                      │    │
+ │  │    create FIXSession { sock, sessionId, senderCompId }           │    │
+ │  │    spawn client recv thread                                       │    │
+ │  └─────────────────────────────────────────────────────────────────��─┘    │
+ │                                                                          │
+ │  ┌─ Client Recv Thread (per session) ───────────────────────────────┐    │
+ │  │  while(loggedOn):                                                 │    │
+ │  │    data = recv(sock)                                              │    │
+ │  │    msgs = parseFIXMessages(data)                                  │    │
+ │  │    for msg in msgs:                                               │    │
+ │  │      switch(msg[35]):                                             │    │
+ │  │        "A" → handleLogon()                                        │    │
+ │  │        "D" → handleNewOrderSingle() → push NewOrderEvent → OEG  │    │
+ │  │        "F" → handleCancelRequest()  → push CancelOrderEvent     │    │
+ │  │        "G" → handleCancelReplace()  → push ModifyOrderEvent     │    │
+ │  │        "5" → logout                                               │    │
+ │  └───────────────────────────────────────────────────────────────────┘    │
+ │                                                                          │
+ │  ┌─ Actor Thread (onEvent) ─────────────────────────────────────────┐    │
+ │  │  onEvent(ExecReportEvent):                                        │    │
+ │  │    find session by sessionId                                      │    │
+ │  │    build FIX ExecutionReport (35=8)                               │    │
+ │  │    send() over TCP to client                                      │    │
+ │  └───────────────────────────────────────────────────────────────────┘    │
+ └──────────────────────────────────────────────────────────────────────────┘
+```
+
+**Supported FIX messages:**
+
+| Tag 35 | Message                     | Direction |
+|--------|-----------------------------|-----------|
+| A      | Logon                       | Inbound   |
+| 5      | Logout                      | Inbound   |
+| 0      | Heartbeat                   | Inbound   |
+| D      | NewOrderSingle              | Inbound   |
+| F      | OrderCancelRequest          | Inbound   |
+| G      | OrderCancelReplaceRequest   | Inbound   |
+| 8      | ExecutionReport             | Outbound  |
+
+**Symbol mapping:**
+
+| Symbol String | SymbolIndex_t |
+|---------------|---------------|
+| AAPL          | 1             |
+| MSFT          | 2             |
+| GOOGL         | 3             |
+| EURO50        | 4             |
+
+---
+
+## 11. Clearing House
+
+### ClearingHouseActor (`src/actors/ClearingHouseActor.hpp`)
+
+```
+ ┌──────────────────────────────────────────────────────────────────────────┐
+ │  ClearingHouseActor                                                      │
+ │                                                                          │
+ │  Session-to-Member Mapping:                                             │
+ │  ┌──────────────────────────────────────────────────────────────────┐    │
+ │  │  SessionId 100-109 ──► MemberId 1-10  (FIX gateway clients)    │    │
+ │  │  SessionId 200-209 ──► MemberId 1-10  (AI traders)             │    │
+ │  └──────────────────────────────────────────────────────────────────┘    │
+ │                                                                          │
+ │  On TradeEvent:                                                         │
+ │  ┌──────────────────────────────────────────────────────────────────┐    │
+ │  │  1. Resolve buySessionId → buyMember                             │    │
+ │  │  2. Resolve sellSessionId → sellMember                           │    │
+ │  │  3. Buy side:                                                    │    │
+ │  │     capital -= price × quantity                                  │    │
+ │  │     holdings[symbol].quantity += quantity                        │    │
+ │  │     holdings[symbol].avgCost updated (weighted average)         │    │
+ │  │  4. Sell side:                                                   │    │
+ │  │     capital += price × quantity                                  │    │
+ │  │     holdings[symbol].quantity -= quantity                        │    │
+ │  │  5. Both sides: tradeCount++                                    │    │
+ │  └──────────────────────────────────────────────────────────────────┘    │
+ │                                                                          │
+ │  Members (10):                                                          │
+ │  ┌────────┬──────────┬─────────────────┬────────┐                       │
+ │  │ Name   │ Capital  │ Holdings        │ Trades │                       │
+ │  ├────────┼──────────┼─────────────────┼────────┤                       │
+ │  │ MBR01  │ 100000.0 │ {sym→qty,cost}  │ 0      │                       │
+ │  │ MBR02  │ 100000.0 │ {sym→qty,cost}  │ 0      │                       │
+ │  │ ...    │ ...      │ ...             │ ...    │                       │
+ │  │ MBR10  │ 100000.0 │ {sym→qty,cost}  │ 0      │                       │
+ │  └────────┴──────────┴─────────────────┴────────┘                       │
+ │                                                                          │
+ │  getLeaderboard():                                                      │
+ │    sorted by capital descending                                         │
+ │    returns: memberId, name, capital, pnl, tradeCount, holdingCount     │
+ │    thread-safe (mutex) for Python bridge reads                          │
+ └──────────────────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## 12. AI Trading Members
+
+### AITraderActor (`src/actors/AITraderActor.hpp`)
+
+```
+ ┌──────────────────────────────────────────────────────────────────────────┐
+ │  AITraderActor — 10 automated trading members                            │
+ │                                                                          │
+ │  Members:                                                               │
+ │  ┌────────┬───────────┬────────────────┬──────────────┐                  │
+ │  │ Name   │ SessionId │ Strategy       │ Description  │                  │
+ │  ├────────┼───────────┼────────────────┼──────────────┤                  │
+ │  │ MBR01  │ 200       │ Momentum       │ Follow trend │                  │
+ │  │ MBR02  │ 201       │ MeanReversion  │ Fade moves   │                  │
+ │  │ MBR03  │ 202       │ Random         │ Noise trader │                  │
+ │  │ MBR04  │ 203       │ Momentum       │              │                  │
+ │  │ ...    │ ...       │ (rotates)      │              │                  │
+ │  │ MBR10  │ 209       │ MeanReversion  │              │                  │
+ │  └────────┴───────────┴────────────────┴──────────────┘                  │
+ │                                                                          │
+ │  Strategy Details:                                                      │
+ │  ┌──────────────────────────────────────────────────────────────────┐    │
+ │  │                                                                  │    │
+ │  │  MOMENTUM:                                                       │    │
+ │  │    if last N prices trending up → BUY (follow the trend)        │    │
+ │  │    if last N prices trending down → SELL                        │    │
+ │  │    price = BBO ± small offset                                   │    │
+ │  │                                                                  │    │
+ │  │  MEAN REVERSION:                                                 │    │
+ │  │    if price > moving average → SELL (expect revert)             │    │
+ │  │    if price < moving average → BUY                              │    │
+ │  │    price = BBO ± small offset                                   │    │
+ │  │                                                                  │    │
+ │  │  RANDOM:                                                         │    │
+ │  │    random side (50/50), random qty (10-100)                     │    │
+ │  │    price around midpoint with random spread                     │    │
+ │  │                                                                  │    │
+ │  └──────────────────────────────────────────────────────────────────┘    │
+ │                                                                          │
+ │  Data Sources:                                                          │
+ │    • BookUpdateEvent → BBO (bestBid, bestAsk) per symbol               │
+ │    • TradeEvent → price history (last 50 prices) per symbol            │
+ │    • ExecReportEvent → order fill confirmations                        │
+ │                                                                          │
+ │  Output:                                                                │
+ │    • NewOrderEvent → OEGActor (via Event::Pipe)                        │
+ │    • ~30s intervals via Actor::Callback                                │
+ └──────────────────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## 13. Project Structure
+
+```
+ EuNEx/
+ ├── CMakeLists.txt                    Build configuration
+ ├── README.md                         Project overview
+ │
+ ├── src/
+ │   ├── main.cpp                      Engine entry point, actor wiring
+ │   │
+ │   ├── common/
+ │   │   ├── Types.hpp                 Core types (Price_t, Order, Trade, etc.)
+ │   │   ├── Book.hpp                  Order book interface
+ │   │   └── Book.cpp                  Price-time priority matching engine
+ │   │
+ │   ├── engine/
+ │   │   └── SimplxShim.hpp            Actor framework (Simplx API compatible)
+ │   │
+ │   ├── actors/
+ │   │   ├── Events.hpp                All inter-actor event definitions
+ │   │   ├── OEGActor.hpp/cpp          Order Entry Gateway
+ │   │   ├── MECoreActor.hpp/cpp       Matching Engine core (per symbol)
+ │   │   ├── MDGActor.hpp/cpp          Market Data Gateway
+ │   │   ├── FIXAcceptorActor.hpp/cpp  FIX 4.4 TCP protocol gateway
+ │   │   ├── ClearingHouseActor.hpp/cpp Trade clearing & member positions
+ │   │   └── AITraderActor.hpp/cpp     Automated trading members
+ │   │
+ │   ├── net/
+ │   │   └── SocketCompat.hpp          Cross-platform socket abstraction
+ │   │
+ │   ├── recovery/
+ │   │   ├── RecoveryProxy.hpp/cpp     Master/Mirror recovery gating
+ │   │   └── (FragmentStore)           In-memory persistence (→ Kafka future)
+ │   │
+ │   ├── iaca/
+ │   │   ├── Fragment.hpp              IACA fragment definitions
+ │   │   ├── IacaAggregator.hpp/cpp    Fragment chain assembly & completion
+ │   │   └── (handlers)                IA message generators
+ │   │
+ │   └── persistence/
+ │       ├── PersistenceStore.hpp       Store interface
+ │       └── KafkaStore.hpp             Kafka adapter (optional, librdkafka)
+ │
+ ├── tests/
+ │   ├── test_orderbook.cpp            Book unit tests (26 cases)
+ │   ├── test_matching_engine.cpp      ME integration tests
+ │   ├── test_threaded_engine.cpp      Multi-threaded actor tests
+ │   ├── test_clearing_house.cpp       Clearing house tests (7 cases)
+ │   ├── test_fix_gateway.cpp          FIX gateway tests (5 cases)
+ │   └── test_ai_trader.cpp            AI trader tests (6 cases)
+ │
+ ├── examples/
+ │   ├── ping_pong.cpp                 Basic actor communication demo
+ │   └── simple_match.cpp              Simple order matching demo
+ │
+ └── docs/
+     ├── developers-guide.md           This document
+     └── process-diagram.md            Detailed Optiq architecture diagrams
+```
+
+---
+
+## 14. Build & Test
+
+### Prerequisites
+
+- **C++20 compiler**: MSVC 19.30+, GCC 12+, Clang 15+
+- **CMake**: 3.16+
+- **Optional**: librdkafka (for Kafka persistence)
+
+### Build Commands
+
+```bash
+# Configure (default: tests ON, Kafka OFF)
+cmake -B build -DEUNEX_BUILD_TESTS=ON
+
+# Build
+cmake --build build --config Release
+
+# Run tests
+cd build && ctest -C Release --output-on-failure
+
+# Run engine
+./build/Release/eunex_me
+```
+
+### CMake Options
+
+| Option               | Default | Description                        |
+|---------------------|---------|------------------------------------|
+| `EUNEX_USE_SIMPLX`  | OFF     | Use real Simplx framework          |
+| `EUNEX_USE_KAFKA`   | OFF     | Enable Kafka persistence           |
+| `EUNEX_BUILD_TESTS` | ON      | Build test binaries                |
+| `EUNEX_BUILD_EXAMPLES` | ON   | Build example binaries             |
+
+### Test Suites
+
+```
+ ┌───────────────────────────────────────────────────────────────┐
+ │  Test Suite              │ Cases │ What it verifies            │
+ ├──────────────────────────┼───────┼─────────────────────────────┤
+ │  OrderBookTest           │  26   │ Book matching, all TIFs,    │
+ │                          │       │ multi-level sweeps, cancels │
+ ├──────────────────────────┼───────┼─────────────────────────────┤
+ │  MatchingEngineTest      │   -   │ MECoreActor event handling  │
+ ├──────────────────────────┼───────┼─────────────────────────────┤
+ │  ThreadedEngineTest      │   -   │ Multi-core Engine, mailbox  │
+ ├──────────────────────────┼───────┼─────────────────────────────┤
+ │  ClearingHouseTest       │   7   │ Capital, holdings, P&L,     │
+ │                          │       │ session mapping, leaderboard│
+ ├──────────────────────────┼───────┼─────────────────────────────┤
+ │  FIXGatewayTest          │   5   │ Symbol mapping, actor       │
+ │                          │       │ lifecycle, OEG routing      │
+ ├──────────────────────────┼───────┼─────────────────────────────┤
+ │  AITraderTest            │   6   │ Strategy execution, multi-  │
+ │                          │       │ symbol, clearing integration│
+ └───────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## 15. Configuration
+
+### Runtime Configuration (main.cpp)
+
+| Parameter            | Value     | Description                          |
+|---------------------|-----------|--------------------------------------|
+| FIX port            | 9001      | FIXAcceptorActor TCP listen port     |
+| Symbols             | 4         | AAPL(1), MSFT(2), GOOGL(3), EURO50(4) |
+| AI members          | 10        | MBR01-MBR10                          |
+| Initial capital     | 100,000.0 | Per clearing member                  |
+| AI trade interval   | ~3s       | Per round in main loop               |
+| Price scale         | 10^8      | Fixed-point decimal places           |
+
+### Seed Orders
+
+The engine pre-populates order books with spread-defining orders:
+
+```
+ AAPL:   Sell 155.00/100, 154.00/200  |  Buy 153.00/150, 152.00/100
+ MSFT:   Sell 325.00/100, 324.00/150  |  Buy 323.00/200, 322.00/100
+ GOOGL:  Sell 142.00/100, 141.00/200  |  Buy 140.00/150, 139.00/100
+ EURO50: Sell 5050.00/50, 5040.00/80  |  Buy 5030.00/60, 5020.00/40
+```
+
+---
+
+## 16. Extending EuNEx
+
+### Adding a New Symbol
+
+1. Define a new `SymbolIndex_t` constant in `main.cpp`
+2. Create a `MECoreActor` for it, passing OEG, MDG, and CH actor IDs
+3. Register it with `oeGateway->mapSymbol(newSym, bookActor->getActorId())`
+4. Add it to `AITraderActor`'s symbol list
+5. Add seed orders if desired
+
+### Adding a New Actor
+
+1. Create `src/actors/MyActor.hpp` inheriting `tredzone::Actor`
+2. Register event handlers in constructor: `registerEventHandler<EventT>(*this)`
+3. Create `Event::Pipe` members for each destination actor
+4. Add `.cpp` to `EUNEX_CORE_SOURCES` in `CMakeLists.txt`
+5. Wire into topology in `main.cpp`
+
+### Adding a New Event Type
+
+1. Define the struct in `src/actors/Events.hpp` inheriting `tredzone::Actor::Event`
+2. Add `onEvent(const MyEvent&)` to receiving actors
+3. Register handler: `registerEventHandler<MyEvent>(*this)`
+4. Push via pipe: `pipe.push<MyEvent>(args...)`
+
+### Adding a New Trading Strategy
+
+1. Add enum value to `Strategy` in `AITraderActor.hpp`
+2. Implement `strategyMyStrategy()` method
+3. Add case to `submitOrder()` switch
+4. Assign to desired members in `initMembers()`
+
+### Future Roadmap
+
+```
+ Current (v0.4)                    Planned
+ ══════════════                    ═══════════════════════════════════
+
+ ✓ Limit + Market orders           □ Stop, Pegged, Mid-Point, Iceberg
+ ✓ IOC, FOK, Day                   □ GTD, GTC, VFU, VFCU
+ ✓ Continuous matching              □ Trading phases (pre-open, close)
+ ✓ FIX 4.4 gateway                 □ FIX 5.0 SP2 + SBE binary
+ ✓ In-memory persistence           □ Kafka persistence
+ ✓ SimplxShim (emulation)          □ Real Simplx multi-core
+ ✓ 4 symbols                       □ Multi-segment, partitions
+ ✓ Single partition                □ Cross-partition routing
+ ✓ Basic clearing                  □ EuroCCP/LCH integration
+ ✓ IACA fragments                  □ IACA FINISH + COPY + IDS
+ ✓ Python bridge (JSON)            □ SBE multicast MDG
+                                    □ SATURN ARM (MiFID II RTS 22)
+                                    □ PTB (Post-Trade Box)
+                                    □ Uncrossing algorithm
+                                    □ Price collars & reservations
+```
+
+---
+
+*Generated for EuNEx v0.4.0 — Euronext Optiq Architecture Simulator*

docs/process-diagram.md

@@ -10,10 +10,10 @@
                                   │
                                   ▼
  ┌────────────────────────────────────────────────────────────────────────────────────┐
- │  OEGatewayActor  (Core 0)                                    ← Optiq: OEG/OEActor│
+ │  OEGActor  (Core 0)                                    ← Optiq: OEG/OEActor│
  │ ┌──────────────────────────────────────────────────────────────────────────────┐   │
  │ │  • Accepts NewOrder / Cancel / Modify requests                              │   │
- │ │  • Validates session, routes by SymbolIndex → correct OrderBookActor        │   │
+ │ │  • Validates session, routes by SymbolIndex → correct MECoreActor        │   │
  │ │  • Sends ExecutionReports back to client (ack, fill, reject)                │   │
  │ └──────────────────────────────────────────────────────────────────────────────┘   │
  └────────────────────────────────┬────────────────────────────────────────────────────┘
@@ -21,7 +21,7 @@
                                   │ (Simplx Event::Pipe — lock-free cross-core delivery)
                                   ▼
  ┌────────────────────────────────────────────────────────────────────────────────────┐
- │  OrderBookActor  (Core 1)  — one per symbol      ← Optiq: LogicalCoreActor + Book│
+ │  MECoreActor  (Core 1)  — one per symbol      ← Optiq: LogicalCoreActor + Book│
  │ ┌──────────────────────────────────────────────────────────────────────────────┐   │
  │ │                        RECOVERY CAUSE                                       │   │
  │ │  RecoveryProxy.cause(persistenceId, order, callback)                        │   │
@@ -31,7 +31,7 @@
  │                                    ▼                                               │
  │ ┌──────────────────────────────────────────────────────────────────────────────┐   │
  │ │                        MATCHING ENGINE                                      │   │
- │ │  OrderBook.newOrder() / cancelOrder() / modifyOrder()                       │   │
+ │ │  Book.newOrder() / cancelOrder() / modifyOrder()                       │   │
  │ │  • Price-time priority matching (std::map<Price, std::deque<Order>>)        │   │
  │ │  • FOK: reject if insufficient liquidity                                    │   │
  │ │  • IOC: fill what's available, cancel remainder                             │   │
@@ -43,7 +43,7 @@
  │ ┌────────────────────┐                    ┌────────────────────────────────────┐   │
  │ │  IACA CAUSE        │                    │  RECOVERY EFFECT (Master only)    │   │
  │ │  IacaFragment:     │                    │  RecoveryProxy.effect(callback)   │   │
- │ │  • BOOK root frag  │                    │  • Sends ExecReport → OEGateway  │   │
+ │ │  • BOOK root frag  │                    │  • Sends ExecReport → OEG  │   │
  │ │  • ACK child frag  │                    │  • Sends TradeEvent → MarketData │   │
  │ │  • TRADE child frag│                    │  • Sends BookUpdate → MarketData │   │
  │ │  (nextCount check) │                    │  • Mirror skips all effects      │   │
@@ -68,7 +68,7 @@
             │ IA message                               │          │
             ▼                                          │          │
  ┌──────────────────────────┐              ┌───────────▼──────────▼──────────────────┐
- │  Future: IDS / PTB /     │              │  MarketDataActor  (Core 2)              │
+ │  Future: IDS / PTB /     │              │  MDGActor  (Core 2)              │
  │  SATURN / Clearing       │              │  ← Optiq: MDLimitLogicalCoreHandler     │
  │ ┌──────────────────────┐ │              │ ┌────────────────────────────────────┐   │
  │ │ IDS: Intraday Data   │ │              │ │ • Maintains BBO snapshot per sym  │   │
@@ -140,17 +140,17 @@
  StockEx (Python/Kafka)          EuNEx (C++/Simplx shim)         Optiq (Production)
  ═══════════════════════         ═══════════════════════          ══════════════════
 
- fix_oeg_server.py         ───▶  OEGatewayActor            ───▶  OEActor (FIX/SBE)
+ fix_oeg_server.py         ───▶  OEGActor                  ───▶  OEActor (FIX/SBE)
    Kafka 'orders' topic    ───▶    Event::Pipe              ───▶    Simplx cross-core
    session mgmt            ───▶    submitNewOrder()          ───▶    FIX 5.0 SP2 acceptor
 
- matcher.py                ───▶  OrderBookActor             ───▶  LogicalCoreActor
-   match_order()           ───▶    OrderBook::newOrder()     ───▶    RecoveryCause→IACA→Book
-   handle_cancel()         ───▶    OrderBook::cancelOrder()  ───▶    CancelOrderData
-   handle_amend()          ───▶    OrderBook::modifyOrder()  ───▶    ModifyOrderData
+ matcher.py                ───▶  MECoreActor                ───▶  LogicalCoreActor
+   match_order()           ───▶    Book::newOrder()          ───▶    RecoveryCause→IACA→Book
+   handle_cancel()         ───▶    Book::cancelOrder()       ───▶    CancelOrderData
+   handle_amend()          ───▶    Book::modifyOrder()       ───▶    ModifyOrderData
    Kafka 'trades' topic    ───▶    TradeEvent via Pipe       ───▶    IACA fragment chain
 
- dashboard.py (SSE)        ───▶  MarketDataActor            ───▶  MDLimitLogicalCoreHandler
+ dashboard.py (SSE)        ───▶  MDGActor                   ───▶  MDLimitLogicalCoreHandler
    /orderbook/<sym>        ───▶    BookUpdateEvent           ───▶    PublishLimitUpdateRequest
    /trades                 ───▶    TradeEvent list           ───▶    IA→SBE multicast
 
@@ -170,16 +170,16 @@
 ## Data Flow Summary
 
 ```
- 1. Client ──FIX/SBE──▶ OEGatewayActor ──Event::Pipe──▶ OrderBookActor
+ 1. Client ──FIX/SBE──▶ OEGActor ──Event::Pipe──▶ MECoreActor
                               ▲                              │
                               │                              ├─ RecoveryProxy.cause() → FragmentStore
-                              │                              ├─ OrderBook.match()
+                              │                              ├─ Book.match()
                               │                              ├─ IACA fragments → IacaAggregator
                               │                              │
                  ExecReport ◀─┘                              ├─ effect() [Master only]:
-                                                             │    ├─ ExecReport → OEGateway → Client
-                                                             │    ├─ TradeEvent → MarketDataActor
-                                                             │    └─ BookUpdate → MarketDataActor
+                                                             │    ├─ ExecReport → OEG → Client
+                                                             │    ├─ TradeEvent → MDGActor
+                                                             │    └─ BookUpdate → MDGActor
                                                              │
                                                              └─ IacaAggregator
                                                                   └─ complete chain → IA message
@@ -203,7 +203,7 @@ and `[FUTURE]` markers where implementation is needed.
              ▼              ▼                      ▼                   ▼
  ┌───────────────┐  ┌──────────────┐    ┌──────────────────┐  ┌────────────────┐
  │  OEG.n.BOTH   │  │  TCS.IN/OUT  │    │  SATURN Web/API  │  │  EMS / DAS     │
- │  (OEGateway   │  │  [FUTURE]    │    │  [FUTURE]        │  │  [FUTURE]      │
+ │  (OEG   │  │  [FUTURE]    │    │  [FUTURE]        │  │  [FUTURE]      │
  │   Actor) ✓    │  │  Trade       │    │  External trade  │  │  Execution     │
  │               │  │  Capture     │    │  declarations    │  │  Mgmt System   │
  └───────┬───────┘  │  Service     │    └────────┬─────────┘  └────────────────┘
@@ -213,11 +213,11 @@ and `[FUTURE]` markers where implementation is needed.
  ┌────────────────────────────────────────────────────────────────────────────────────────┐
  │  ME / Trading Chain                                                                    │
  │ ┌────────────────────────────────────────────────────────────────────────────────────┐  │
- │ │  Book / LogCore#n  (OrderBookActor) ✓                                              │  │
+ │ │  Book / LogCore#n  (MECoreActor) ✓                                              │  │
  │ │                                                                                    │  │
  │ │  ┌─────────────────┐  ┌─────────────────┐  ┌─────────────────┐                    │  │
  │ │  │ Recovery Cause  │  │ Matching Engine │  │ IACA Inside     │                    │  │
- │ │  │ (RecoveryProxy  │  │ (OrderBook) ✓   │  │ (IacaAggregator │                    │  │
+ │ │  │ (RecoveryProxy  │  │ (Book) ✓   │  │ (IacaAggregator │                    │  │
  │ │  │  → Kafka) ✓     │  │                 │  │  partial) ✓     │                    │  │
  │ │  └────────┬────────┘  └────────┬────────┘  └────────┬────────┘                    │  │
  │ │           │                    │                     │                              │  │
@@ -438,7 +438,7 @@ From the Optiq Architecture presentation.
  │    • Inherits trading group attributes                              │
  │    • Can override: APF (Authorized Price Fluctuation)               │
  │                                                                     │
- │  EuNEx currently: OrderBookActor per symbol, single "partition"    │
+ │  EuNEx currently: MECoreActor per symbol, single "partition"    │
  │  [FUTURE] PartitionManager distributes symbols across nodes         │
  └─────────────────────────────────────────────────────────────────────┘
 ```
@@ -585,8 +585,8 @@ From Trading Manual Section 5.
 
 ```
  Phase 1 (Current) ✓ DONE
- ├── OrderBook with price-time priority matching
- ├── OEGatewayActor → OrderBookActor → MarketDataActor pipeline
+ ├── Book with price-time priority matching
+ ├── OEGActor → MECoreActor → MDGActor pipeline
  ├── Recovery Cause/Effect with Master/Mirror gating
  ├── IACA fragment chains with completion detection
  └── Simplx shim for single-threaded testing

examples/simple_match.cpp

@@ -12,7 +12,7 @@
 // ════════════════════════════════════════════════════════════════════
 
 #include "engine/SimplxShim.hpp"
-#include "common/OrderBook.hpp"
+#include "common/Book.hpp"
 #include "recovery/RecoveryProxy.hpp"
 #include "iaca/Fragment.hpp"
 #include "iaca/IacaAggregator.hpp"
@@ -40,7 +40,7 @@ int main() {
         }
     ));
 
-    OrderBook book(1);
+    Book book(1);
 
     // ── Process a sell order (Optiq-style) ─────────────────────────
     std::cout << "── Processing SELL 100 @ 50.00 ──\n";
@@ -177,7 +177,7 @@ int main() {
     // ── Simulate Mirror replay ─────────────────────────────────────
     std::cout << "\n── Mirror Replay Simulation ──────────────\n";
     RecoveryProxy mirrorProxy(ORIGIN_BOOK, 1, store, /*isMaster=*/false);
-    OrderBook mirrorBook(1);
+    Book mirrorBook(1);
 
     // Effects should NOT fire on mirror
     mirrorProxy.effect([]() {

src/actors/AITraderActor.hpp

@@ -9,7 +9,7 @@
 //
 // Uses Actor::Callback for periodic trading decisions (~30s intervals).
 // Receives BookUpdateEvent for BBO data and TradeEvent for price history.
-// Pushes NewOrderEvent to OEGateway.
+// Pushes NewOrderEvent to OEGActor.
 // ════════════════════════════════════════════════════════════════════
 
 #include "engine/SimplxShim.hpp"

src/actors/ClearingHouseActor.hpp

@@ -4,7 +4,7 @@
 //
 // Optiq equivalent: Clearing House downstream from Kafka Bus / PTB
 //
-// Receives TradeEvent from OrderBookActor(s), attributes trades to
+// Receives TradeEvent from MECoreActor(s), attributes trades to
 // members via SessionId→MemberId mapping, maintains capital and
 // holdings per member. Exposes thread-safe getLeaderboard() for
 // the Python bridge to read.

src/actors/{FIXGatewayActor.cpp → FIXAcceptorActor.cpp}

@@ -1,4 +1,4 @@
-#include "actors/FIXGatewayActor.hpp"
+#include "actors/FIXAcceptorActor.hpp"
 #include <iostream>
 #include <sstream>
 #include <cstring>
@@ -9,7 +9,7 @@
 
 namespace eunex {
 
-FIXGatewayActor::FIXGatewayActor(const tredzone::ActorId& oeGatewayId, uint16_t port)
+FIXAcceptorActor::FIXAcceptorActor(const tredzone::ActorId& oeGatewayId, uint16_t port)
     : oePipe_(*this, oeGatewayId)
     , port_(port)
 {
@@ -22,7 +22,7 @@ FIXGatewayActor::FIXGatewayActor(const tredzone::ActorId& oeGatewayId, uint16_t
 
     listenSock_ = socket(AF_INET, SOCK_STREAM, 0);
     if (listenSock_ == INVALID_SOCK) {
-        std::cerr << "FIXGateway: socket() failed\n";
+        std::cerr << "FIXAcceptor: socket() failed\n";
         return;
     }
 
@@ -34,30 +34,30 @@ FIXGatewayActor::FIXGatewayActor(const tredzone::ActorId& oeGatewayId, uint16_t
     addr.sin_port = htons(port_);
 
     if (bind(listenSock_, reinterpret_cast<sockaddr*>(&addr), sizeof(addr)) != 0) {
-        std::cerr << "FIXGateway: bind() failed on port " << port_ << "\n";
+        std::cerr << "FIXAcceptor: bind() failed on port " << port_ << "\n";
         closeSocket(listenSock_);
         listenSock_ = INVALID_SOCK;
         return;
     }
 
     if (listen(listenSock_, 5) != 0) {
-        std::cerr << "FIXGateway: listen() failed\n";
+        std::cerr << "FIXAcceptor: listen() failed\n";
         closeSocket(listenSock_);
         listenSock_ = INVALID_SOCK;
         return;
     }
 
     running_ = true;
-    acceptThread_ = std::thread(&FIXGatewayActor::acceptLoop, this);
+    acceptThread_ = std::thread(&FIXAcceptorActor::acceptLoop, this);
 
-    std::cout << "FIXGateway: listening on port " << port_ << "\n";
+    std::cout << "FIXAcceptor: listening on port " << port_ << "\n";
 }
 
-FIXGatewayActor::~FIXGatewayActor() {
+FIXAcceptorActor::~FIXAcceptorActor() {
     stop();
 }
 
-void FIXGatewayActor::stop() {
+void FIXAcceptorActor::stop() {
     if (!running_.exchange(false)) return;
 
     if (listenSock_ != INVALID_SOCK) {
@@ -83,14 +83,14 @@ void FIXGatewayActor::stop() {
     sessions_.clear();
 }
 
-int FIXGatewayActor::clientCount() const {
+int FIXAcceptorActor::clientCount() const {
     std::lock_guard<std::mutex> lock(sessionMutex_);
     return static_cast<int>(sessions_.size());
 }
 
 // ── Accept loop (background thread) ──────────────────────────────
 
-void FIXGatewayActor::acceptLoop() {
+void FIXAcceptorActor::acceptLoop() {
     while (running_) {
         sockaddr_in clientAddr{};
         socklen_t len = sizeof(clientAddr);
@@ -98,7 +98,7 @@ void FIXGatewayActor::acceptLoop() {
                                       reinterpret_cast<sockaddr*>(&clientAddr), &len);
 
         if (clientSock == INVALID_SOCK) {
-            if (running_) std::cerr << "FIXGateway: accept() failed\n";
+            if (running_) std::cerr << "FIXAcceptor: accept() failed\n";
             continue;
         }
 
@@ -112,16 +112,16 @@ void FIXGatewayActor::acceptLoop() {
         sess->loggedOn = false;
 
         FIXSession* raw = sess.get();
-        sess->recvThread = std::thread(&FIXGatewayActor::clientRecvLoop, this, sessId);
+        sess->recvThread = std::thread(&FIXAcceptorActor::clientRecvLoop, this, sessId);
 
         sessions_[sessId] = std::move(sess);
-        std::cout << "FIXGateway: client connected (session " << sessId << ")\n";
+        std::cout << "FIXAcceptor: client connected (session " << sessId << ")\n";
     }
 }
 
 // ── Client recv loop (per-client thread) ─────────────────────────
 
-void FIXGatewayActor::clientRecvLoop(SessionId_t sessionId) {
+void FIXAcceptorActor::clientRecvLoop(SessionId_t sessionId) {
     socket_t sock;
     {
         std::lock_guard<std::mutex> lock(sessionMutex_);
@@ -177,7 +177,7 @@ void FIXGatewayActor::clientRecvLoop(SessionId_t sessionId) {
 
 // ── FIX message parsing ──────────────────────────────────────────
 
-std::vector<FIXGatewayActor::TagMap> FIXGatewayActor::parseFIXMessages(const std::string& data) {
+std::vector<FIXAcceptorActor::TagMap> FIXAcceptorActor::parseFIXMessages(const std::string& data) {
     std::vector<TagMap> result;
     std::string remaining = data;
 
@@ -213,17 +213,17 @@ std::vector<FIXGatewayActor::TagMap> FIXGatewayActor::parseFIXMessages(const std
     return result;
 }
 
-std::string FIXGatewayActor::getTag(const TagMap& msg, int tag, const std::string& def) {
+std::string FIXAcceptorActor::getTag(const TagMap& msg, int tag, const std::string& def) {
     auto it = msg.find(tag);
     return (it != msg.end()) ? it->second : def;
 }
 
 // ── FIX message handlers ─────────────────────────────────────────
 
-void FIXGatewayActor::handleLogon(FIXSession& sess, const TagMap& msg) {
+void FIXAcceptorActor::handleLogon(FIXSession& sess, const TagMap& msg) {
     sess.senderCompId = getTag(msg, 49, "UNKNOWN");
     sess.loggedOn = true;
-    std::cout << "FIXGateway: Logon from " << sess.senderCompId
+    std::cout << "FIXAcceptor: Logon from " << sess.senderCompId
               << " (session " << sess.sessionId << ")\n";
 
     sendFIX(sess, "A", {
@@ -232,7 +232,7 @@ void FIXGatewayActor::handleLogon(FIXSession& sess, const TagMap& msg) {
     });
 }
 
-void FIXGatewayActor::handleNewOrderSingle(FIXSession& sess, const TagMap& msg) {
+void FIXAcceptorActor::handleNewOrderSingle(FIXSession& sess, const TagMap& msg) {
     std::string clOrdIdStr = getTag(msg, 11);
     std::string symbol = getTag(msg, 55);
     std::string sideStr = getTag(msg, 54);
@@ -256,7 +256,7 @@ void FIXGatewayActor::handleNewOrderSingle(FIXSession& sess, const TagMap& msg)
     oePipe_.push<NewOrderEvent>(clOrdId, symIdx, side, ordType, tif, price, qty, sess.sessionId);
 }
 
-void FIXGatewayActor::handleCancelRequest(FIXSession& sess, const TagMap& msg) {
+void FIXAcceptorActor::handleCancelRequest(FIXSession& sess, const TagMap& msg) {
     std::string origClOrdIdStr = getTag(msg, 41);
     std::string orderIdStr = getTag(msg, 37, "0");
     std::string symbol = getTag(msg, 55);
@@ -268,7 +268,7 @@ void FIXGatewayActor::handleCancelRequest(FIXSession& sess, const TagMap& msg) {
     oePipe_.push<CancelOrderEvent>(orderId, origClOrdId, symIdx, sess.sessionId);
 }
 
-void FIXGatewayActor::handleCancelReplaceRequest(FIXSession& sess, const TagMap& msg) {
+void FIXAcceptorActor::handleCancelReplaceRequest(FIXSession& sess, const TagMap& msg) {
     std::string orderIdStr = getTag(msg, 37, "0");
     std::string origClOrdIdStr = getTag(msg, 41);
     std::string symbol = getTag(msg, 55);
@@ -286,7 +286,7 @@ void FIXGatewayActor::handleCancelReplaceRequest(FIXSession& sess, const TagMap&
 
 // ── Send FIX message ─────────────────────────────────────────────
 
-void FIXGatewayActor::sendFIX(FIXSession& sess, const std::string& msgType,
+void FIXAcceptorActor::sendFIX(FIXSession& sess, const std::string& msgType,
                                const std::vector<std::pair<int, std::string>>& fields) {
     std::ostringstream body;
     body << "35=" << msgType << '\x01';
@@ -333,11 +333,11 @@ void FIXGatewayActor::sendFIX(FIXSession& sess, const std::string& msgType,
 
 // ── Exec report handling ─────────────────────────────────────────
 
-void FIXGatewayActor::onEvent(const ExecReportEvent& event) {
+void FIXAcceptorActor::onEvent(const ExecReportEvent& event) {
     sendExecReport(event.sessionId, event);
 }
 
-void FIXGatewayActor::sendExecReport(SessionId_t sessionId, const ExecReportEvent& rpt) {
+void FIXAcceptorActor::sendExecReport(SessionId_t sessionId, const ExecReportEvent& rpt) {
     std::lock_guard<std::mutex> lock(sessionMutex_);
     auto it = sessions_.find(sessionId);
     if (it == sessions_.end()) return;
@@ -386,7 +386,7 @@ void FIXGatewayActor::sendExecReport(SessionId_t sessionId, const ExecReportEven
 
 // ── Symbol mapping ───────────────────────────────────────────────
 
-SymbolIndex_t FIXGatewayActor::symbolFromString(const std::string& sym) {
+SymbolIndex_t FIXAcceptorActor::symbolFromString(const std::string& sym) {
     if (sym == "AAPL")   return 1;
     if (sym == "MSFT")   return 2;
     if (sym == "GOOGL")  return 3;
@@ -394,7 +394,7 @@ SymbolIndex_t FIXGatewayActor::symbolFromString(const std::string& sym) {
     return static_cast<SymbolIndex_t>(std::strtoul(sym.c_str(), nullptr, 10));
 }
 
-std::string FIXGatewayActor::symbolToString(SymbolIndex_t idx) {
+std::string FIXAcceptorActor::symbolToString(SymbolIndex_t idx) {
     switch (idx) {
         case 1: return "AAPL";
         case 2: return "MSFT";

src/actors/{FIXGatewayActor.hpp → FIXAcceptorActor.hpp}

@@ -1,13 +1,13 @@
 #pragma once
 // ════════════════════════════════════════════════════════════════════
-// FIXGatewayActor — C++ FIX 4.4 TCP acceptor
+// FIXAcceptorActor — C++ FIX 4.4 TCP acceptor
 //
 // Optiq equivalent: OEG FIX Gateway (FIX 4.4 acceptor for OE frontal)
 //
 // Runs a TCP accept loop on a background thread. Each connected client
 // gets a recv thread that parses FIX messages and enqueues them to the
 // actor's mailbox. The actor thread pushes NewOrderEvent / CancelEvent
-// to OEGateway via Event::Pipe.
+// to OEGActor via Event::Pipe.
 //
 // Supported messages:
 //   Logon (35=A), Logout (35=5), Heartbeat (35=0),
@@ -40,12 +40,12 @@ struct FIXSession {
     std::thread recvThread;
 };
 
-class FIXGatewayActor : public tredzone::Actor {
+class FIXAcceptorActor : public tredzone::Actor {
 public:
     struct Service : tredzone::AsyncService {};
 
-    FIXGatewayActor(const tredzone::ActorId& oeGatewayId, uint16_t port = 9001);
-    ~FIXGatewayActor();
+    FIXAcceptorActor(const tredzone::ActorId& oeGatewayId, uint16_t port = 9001);
+    ~FIXAcceptorActor();
 
     void onEvent(const ExecReportEvent& event);
 

src/actors/{MarketDataActor.cpp → MDGActor.cpp}

@@ -1,13 +1,13 @@
-#include "actors/MarketDataActor.hpp"
+#include "actors/MDGActor.hpp"
 
 namespace eunex {
 
-MarketDataActor::MarketDataActor() {
+MDGActor::MDGActor() {
     registerEventHandler<TradeEvent>(*this);
     registerEventHandler<BookUpdateEvent>(*this);
 }
 
-void MarketDataActor::onEvent(const TradeEvent& event) {
+void MDGActor::onEvent(const TradeEvent& event) {
     const auto& t = event.trade;
     auto& snap = snapshots_[t.symbolIdx];
     snap.symbolIdx      = t.symbolIdx;
@@ -22,7 +22,7 @@ void MarketDataActor::onEvent(const TradeEvent& event) {
     }
 }
 
-void MarketDataActor::onEvent(const BookUpdateEvent& event) {
+void MDGActor::onEvent(const BookUpdateEvent& event) {
     auto& snap = snapshots_[event.symbolIdx];
     snap.symbolIdx = event.symbolIdx;
     snap.updateTime = nowNs();
@@ -42,7 +42,7 @@ void MarketDataActor::onEvent(const BookUpdateEvent& event) {
     }
 }
 
-const MarketDataSnapshot* MarketDataActor::getSnapshot(SymbolIndex_t sym) const {
+const MarketDataSnapshot* MDGActor::getSnapshot(SymbolIndex_t sym) const {
     auto it = snapshots_.find(sym);
     return it != snapshots_.end() ? &it->second : nullptr;
 }

src/actors/{MarketDataActor.hpp → MDGActor.hpp}

@@ -1,6 +1,6 @@
 #pragma once
 // ════════════════════════════════════════════════════════════════════
-// MarketDataActor — Market Data Publisher
+// MDGActor — Market Data Publisher
 //
 // StockEx equivalent: dashboard.py SSE streaming + mdf_simulator.py
 //   - Receives trades/snapshots, streams to UI
@@ -30,11 +30,11 @@ struct MarketDataSnapshot {
     Timestamp_ns  updateTime;
 };
 
-class MarketDataActor : public tredzone::Actor {
+class MDGActor : public tredzone::Actor {
 public:
     struct Service : tredzone::AsyncService {};
 
-    MarketDataActor();
+    MDGActor();
 
     void onEvent(const TradeEvent& event);
     void onEvent(const BookUpdateEvent& event);

src/actors/{OrderBookActor.cpp → MECoreActor.cpp}

@@ -1,9 +1,9 @@
-#include "actors/OrderBookActor.hpp"
+#include "actors/MECoreActor.hpp"
 #include <iostream>
 
 namespace eunex {
 
-OrderBookActor::OrderBookActor(SymbolIndex_t symbolIdx,
+MECoreActor::MECoreActor(SymbolIndex_t symbolIdx,
                                const tredzone::ActorId& oeGatewayId,
                                const tredzone::ActorId& marketDataId,
                                const tredzone::ActorId& clearingHouseId)
@@ -23,7 +23,7 @@ OrderBookActor::OrderBookActor(SymbolIndex_t symbolIdx,
 // StockEx: match_order(order, producer)
 // Optiq:   RecoveryCause.onInput → CauseOperator → forwardToBook()
 
-void OrderBookActor::onEvent(const NewOrderEvent& event) {
+void MECoreActor::onEvent(const NewOrderEvent& event) {
     Order order{};
     order.clOrdId    = event.clOrdId;
     order.symbolIdx  = event.symbolIdx;
@@ -57,7 +57,7 @@ void OrderBookActor::onEvent(const NewOrderEvent& event) {
 // ── Cancel ─────────────────────────────────────────────────────────
 // StockEx: handle_cancel(msg, producer)
 
-void OrderBookActor::onEvent(const CancelOrderEvent& event) {
+void MECoreActor::onEvent(const CancelOrderEvent& event) {
     ExecutionReport rpt{};
     if (book_.cancelOrder(event.orderId, rpt)) {
         oePipe_.push<ExecReportEvent>(rpt, event.sessionId);
@@ -72,7 +72,7 @@ void OrderBookActor::onEvent(const CancelOrderEvent& event) {
 // ── Modify (Cancel-Replace) ────────────────────────────────────────
 // StockEx: handle_amend(msg, producer)
 
-void OrderBookActor::onEvent(const ModifyOrderEvent& event) {
+void MECoreActor::onEvent(const ModifyOrderEvent& event) {
     ExecutionReport rpt{};
     if (book_.modifyOrder(event.orderId, event.newPrice, event.newQuantity, rpt)) {
         oePipe_.push<ExecReportEvent>(rpt, event.sessionId);
@@ -88,7 +88,7 @@ void OrderBookActor::onEvent(const ModifyOrderEvent& event) {
 // StockEx: the Dashboard reads orderbook via REST GET /orderbook/<symbol>
 // Optiq:   publishLimitEffect → push to MDLimitLogicalCoreHandler
 
-void OrderBookActor::publishBookUpdate() {
+void MECoreActor::publishBookUpdate() {
     BookUpdateEvent update;
     update.symbolIdx = book_.symbolIndex();
 

src/actors/{OrderBookActor.hpp → MECoreActor.hpp}

@@ -1,6 +1,6 @@
 #pragma once
 // ════════════════════════════════════════════════════════════════════
-// OrderBookActor — The matching engine core
+// MECoreActor — The matching engine core
 //
 // StockEx equivalent: matcher.py (match_order, handle_cancel, handle_amend)
 // Optiq equivalent:   LogicalCoreActor + RecoveryHelperCore + Book
@@ -17,17 +17,17 @@
 // ════════════════════════════════════════════════════════════════════
 
 #include "engine/SimplxShim.hpp"
-#include "common/OrderBook.hpp"
+#include "common/Book.hpp"
 #include "actors/Events.hpp"
 #include <optional>
 
 namespace eunex {
 
-class OrderBookActor : public tredzone::Actor {
+class MECoreActor : public tredzone::Actor {
 public:
     struct Service : tredzone::AsyncService {};
 
-    OrderBookActor(SymbolIndex_t symbolIdx,
+    MECoreActor(SymbolIndex_t symbolIdx,
                    const tredzone::ActorId& oeGatewayId,
                    const tredzone::ActorId& marketDataId,
                    const tredzone::ActorId& clearingHouseId = tredzone::ActorId{});
@@ -37,7 +37,7 @@ public:
     void onEvent(const ModifyOrderEvent& event);
 
 private:
-    OrderBook book_;
+    Book book_;
     tredzone::Actor::Event::Pipe oePipe_;
     tredzone::Actor::Event::Pipe mdPipe_;
     std::optional<tredzone::Actor::Event::Pipe> chPipe_;

src/actors/{OEGatewayActor.cpp → OEGActor.cpp}

@@ -1,25 +1,25 @@
-#include "actors/OEGatewayActor.hpp"
+#include "actors/OEGActor.hpp"
 
 namespace eunex {
 
-OEGatewayActor::OEGatewayActor() {
+OEGActor::OEGActor() {
     registerEventHandler<NewOrderEvent>(*this);
     registerEventHandler<CancelOrderEvent>(*this);
     registerEventHandler<ModifyOrderEvent>(*this);
     registerEventHandler<ExecReportEvent>(*this);
 }
 
-void OEGatewayActor::mapSymbol(SymbolIndex_t symbolIdx,
+void OEGActor::mapSymbol(SymbolIndex_t symbolIdx,
                                 const tredzone::ActorId& bookActorId) {
     symbolMap_[symbolIdx] = bookActorId;
 }
 
-void OEGatewayActor::submitNewOrder(ClOrdId_t clOrdId, SymbolIndex_t symbolIdx,
+void OEGActor::submitNewOrder(ClOrdId_t clOrdId, SymbolIndex_t symbolIdx,
                                      Side side, OrderType ordType, TimeInForce tif,
                                      Price_t price, Quantity_t qty, SessionId_t session) {
     auto it = symbolMap_.find(symbolIdx);
     if (it == symbolMap_.end()) {
-        std::cerr << "OEGateway: unknown symbol " << symbolIdx << "\n";
+        std::cerr << "OEG: unknown symbol " << symbolIdx << "\n";
         return;
     }
 
@@ -27,7 +27,7 @@ void OEGatewayActor::submitNewOrder(ClOrdId_t clOrdId, SymbolIndex_t symbolIdx,
     pipe.push<NewOrderEvent>(clOrdId, symbolIdx, side, ordType, tif, price, qty, session);
 }
 
-void OEGatewayActor::submitCancel(OrderId_t orderId, ClOrdId_t origClOrdId,
+void OEGActor::submitCancel(OrderId_t orderId, ClOrdId_t origClOrdId,
                                    SymbolIndex_t symbolIdx, SessionId_t session) {
     auto it = symbolMap_.find(symbolIdx);
     if (it == symbolMap_.end()) return;
@@ -36,7 +36,7 @@ void OEGatewayActor::submitCancel(OrderId_t orderId, ClOrdId_t origClOrdId,
     pipe.push<CancelOrderEvent>(orderId, origClOrdId, symbolIdx, session);
 }
 
-void OEGatewayActor::submitModify(OrderId_t orderId, ClOrdId_t origClOrdId,
+void OEGActor::submitModify(OrderId_t orderId, ClOrdId_t origClOrdId,
                                    SymbolIndex_t symbolIdx, Price_t newPrice,
                                    Quantity_t newQty, SessionId_t session) {
     auto it = symbolMap_.find(symbolIdx);
@@ -46,25 +46,25 @@ void OEGatewayActor::submitModify(OrderId_t orderId, ClOrdId_t origClOrdId,
     pipe.push<ModifyOrderEvent>(orderId, origClOrdId, symbolIdx, newPrice, newQty, session);
 }
 
-void OEGatewayActor::onEvent(const NewOrderEvent& event) {
+void OEGActor::onEvent(const NewOrderEvent& event) {
     submitNewOrder(event.clOrdId, event.symbolIdx, event.side, event.ordType,
                     event.tif, event.price, event.quantity, event.sessionId);
 }
 
-void OEGatewayActor::onEvent(const CancelOrderEvent& event) {
+void OEGActor::onEvent(const CancelOrderEvent& event) {
     submitCancel(event.orderId, event.origClOrdId, event.symbolIdx, event.sessionId);
 }
 
-void OEGatewayActor::onEvent(const ModifyOrderEvent& event) {
+void OEGActor::onEvent(const ModifyOrderEvent& event) {
     submitModify(event.orderId, event.origClOrdId, event.symbolIdx,
                   event.newPrice, event.newQuantity, event.sessionId);
 }
 
-void OEGatewayActor::addExecReportSubscriber(const tredzone::ActorId& subscriberId) {
+void OEGActor::addExecReportSubscriber(const tredzone::ActorId& subscriberId) {
     execReportSubscribers_.push_back(subscriberId);
 }
 
-void OEGatewayActor::onEvent(const ExecReportEvent& event) {
+void OEGActor::onEvent(const ExecReportEvent& event) {
     reports_.push_back(event);
 
     for (auto& subId : execReportSubscribers_) {

src/actors/{OEGatewayActor.hpp → OEGActor.hpp}

@@ -1,10 +1,10 @@
 #pragma once
 // ════════════════════════════════════════════════════════════════════
-// OEGatewayActor — Order Entry Gateway
+// OEGActor — Order Entry Gateway
 //
 // StockEx equivalent: fix_oeg_server.py + consumer.py
 //   - Receives FIX messages, normalizes them, pushes to Kafka
-//   - Here: receives external input and routes to OrderBookActor
+//   - Here: receives external input and routes to MECoreActor
 //
 // Optiq equivalent: OEActor
 //   - Receives messages from OE frontal (SBE over TCP)
@@ -20,11 +20,11 @@
 
 namespace eunex {
 
-class OEGatewayActor : public tredzone::Actor {
+class OEGActor : public tredzone::Actor {
 public:
     struct Service : tredzone::AsyncService {};
 
-    OEGatewayActor();
+    OEGActor();
 
     // Register an OrderBook actor for a symbol
     void mapSymbol(SymbolIndex_t symbolIdx, const tredzone::ActorId& bookActorId);

src/common/{OrderBook.cpp → Book.cpp}

@@ -1,14 +1,14 @@
-#include "common/OrderBook.hpp"
+#include "common/Book.hpp"
 #include <algorithm>
 
 namespace eunex {
 
-OrderBook::OrderBook(SymbolIndex_t symbolIdx)
+Book::Book(SymbolIndex_t symbolIdx)
     : symbolIdx_(symbolIdx) {}
 
 // ── New Order Entry ────────────────────────────────────────────────
 
-void OrderBook::newOrder(Order& order, const TradeCallback& onTrade,
+void Book::newOrder(Order& order, const TradeCallback& onTrade,
                          const ExecCallback& onExec) {
     order.orderId = allocateOrderId();
     order.remainingQty = order.quantity;
@@ -76,7 +76,7 @@ void OrderBook::newOrder(Order& order, const TradeCallback& onTrade,
 
 // ── Matching: Buy against Asks ─────────────────────────────────────
 
-void OrderBook::matchBuy(Order& incoming, const TradeCallback& onTrade,
+void Book::matchBuy(Order& incoming, const TradeCallback& onTrade,
                          const ExecCallback& onExec) {
     auto it = asks_.begin();
     while (incoming.remainingQty > 0 && it != asks_.end()) {
@@ -133,7 +133,7 @@ void OrderBook::matchBuy(Order& incoming, const TradeCallback& onTrade,
 
 // ── Matching: Sell against Bids ────────────────────────────────────
 
-void OrderBook::matchSell(Order& incoming, const TradeCallback& onTrade,
+void Book::matchSell(Order& incoming, const TradeCallback& onTrade,
                           const ExecCallback& onExec) {
     auto it = bids_.begin();
     while (incoming.remainingQty > 0 && it != bids_.end()) {
@@ -189,7 +189,7 @@ void OrderBook::matchSell(Order& incoming, const TradeCallback& onTrade,
 
 // ── Cancel ─────────────────────────────────────────────────────────
 
-bool OrderBook::cancelOrder(OrderId_t orderId, ExecutionReport& report) {
+bool Book::cancelOrder(OrderId_t orderId, ExecutionReport& report) {
     auto it = orderIndex_.find(orderId);
     if (it == orderIndex_.end())
         return false;
@@ -232,7 +232,7 @@ bool OrderBook::cancelOrder(OrderId_t orderId, ExecutionReport& report) {
 
 // ── Modify (Cancel-Replace) ────────────────────────────────────────
 
-bool OrderBook::modifyOrder(OrderId_t orderId, Price_t newPrice, Quantity_t newQty,
+bool Book::modifyOrder(OrderId_t orderId, Price_t newPrice, Quantity_t newQty,
                             ExecutionReport& report) {
     ExecutionReport cancelRpt{};
     if (!cancelOrder(orderId, cancelRpt))
@@ -259,7 +259,7 @@ bool OrderBook::modifyOrder(OrderId_t orderId, Price_t newPrice, Quantity_t newQ
 
 // ── Insert resting order ───────────────────────────────────────────
 
-void OrderBook::insertResting(Order& order) {
+void Book::insertResting(Order& order) {
     orderIndex_[order.orderId] = {order.side, order.price};
     if (order.side == Side::Buy) {
         bids_[order.price].push_back(order);
@@ -268,7 +268,7 @@ void OrderBook::insertResting(Order& order) {
     }
 }
 
-void OrderBook::removeOrder(OrderId_t orderId, Side side, Price_t price) {
+void Book::removeOrder(OrderId_t orderId, Side side, Price_t price) {
     orderIndex_.erase(orderId);
     if (side == Side::Buy) {
         auto it = bids_.find(price);
@@ -292,7 +292,7 @@ void OrderBook::removeOrder(OrderId_t orderId, Side side, Price_t price) {
 // ── Query helpers ──────────────────────────────────────────────────
 
 template<typename MapT>
-std::vector<OrderBook::Level> OrderBook::getLevels(const MapT& map, int depth) const {
+std::vector<Book::Level> Book::getLevels(const MapT& map, int depth) const {
     std::vector<Level> result;
     result.reserve(depth);
     int count = 0;
@@ -306,21 +306,21 @@ std::vector<OrderBook::Level> OrderBook::getLevels(const MapT& map, int depth) c
     return result;
 }
 
-std::vector<OrderBook::Level> OrderBook::getBids(int depth) const {
+std::vector<Book::Level> Book::getBids(int depth) const {
     return getLevels(bids_, depth);
 }
 
-std::vector<OrderBook::Level> OrderBook::getAsks(int depth) const {
+std::vector<Book::Level> Book::getAsks(int depth) const {
     return getLevels(asks_, depth);
 }
 
-size_t OrderBook::bidCount() const {
+size_t Book::bidCount() const {
     size_t count = 0;
     for (auto& [_, orders] : bids_) count += orders.size();
     return count;
 }
 
-size_t OrderBook::askCount() const {
+size_t Book::askCount() const {
     size_t count = 0;
     for (auto& [_, orders] : asks_) count += orders.size();
     return count;

src/common/{OrderBook.hpp → Book.hpp}

@@ -16,12 +16,12 @@ using ExecCallback  = std::function<void(const ExecutionReport&)>;
 // Mirrors StockEx matcher.py logic but uses sorted std::map for O(log N)
 // insert/match instead of Python list.sort() on every match.
 //
-// In Optiq, each OrderBookActor owns exactly one OrderBook instance.
+// In Optiq, each BookActor owns exactly one Book instance.
 // The actor guarantees single-threaded access — no locks needed.
 //
-class OrderBook {
+class Book {
 public:
-    explicit OrderBook(SymbolIndex_t symbolIdx);
+    explicit Book(SymbolIndex_t symbolIdx);
 
     // Insert a new order and attempt matching. Returns executions via callbacks.
     void newOrder(Order& order, const TradeCallback& onTrade, const ExecCallback& onExec);

src/main.cpp

@@ -3,9 +3,9 @@
 //
 // Multi-threaded actor topology (mirrors Optiq architecture):
 //
-//   Core 0: OEGatewayActor + FIXGatewayActor
-//   Core 1: OrderBookActor per symbol (matching engine)
-//   Core 2: MarketDataActor
+//   Core 0: OEGActor + FIXAcceptorActor
+//   Core 1: MECoreActor per symbol (matching engine)
+//   Core 2: MDGActor
 //   Core 3: ClearingHouseActor + AITraderActor
 //
 // Optiq equivalent topology:
@@ -15,11 +15,11 @@
 // ════════════════════════════════════════════════════════════════════
 
 #include "engine/SimplxShim.hpp"
-#include "actors/OrderBookActor.hpp"
-#include "actors/OEGatewayActor.hpp"
-#include "actors/MarketDataActor.hpp"
+#include "actors/MECoreActor.hpp"
+#include "actors/OEGActor.hpp"
+#include "actors/MDGActor.hpp"
 #include "actors/ClearingHouseActor.hpp"
-#include "actors/FIXGatewayActor.hpp"
+#include "actors/FIXAcceptorActor.hpp"
 #include "actors/AITraderActor.hpp"
 #include <iostream>
 #include <thread>
@@ -52,10 +52,10 @@ int main() {
     std::vector<SymbolIndex_t> allSymbols = {SYM_AAPL, SYM_MSFT, SYM_GOOGL, SYM_EURO50};
 
     // ── Core 0: OE Gateway ────────────────────────────────────────
-    auto oeGateway = std::make_unique<OEGatewayActor>();
+    auto oeGateway = std::make_unique<OEGActor>();
 
     // ── Core 2: Market Data ───────────────────────────────────────
-    auto mdActor = std::make_unique<MarketDataActor>();
+    auto mdActor = std::make_unique<MDGActor>();
 
     // ── Core 3: Clearing House ────────────────────────────────────
     auto chActor = std::make_unique<ClearingHouseActor>();
@@ -72,13 +72,13 @@ int main() {
     }
 
     // ── Core 1: Order Books (per symbol) ──────────────────────────
-    auto bookAAPL = std::make_unique<OrderBookActor>(
+    auto bookAAPL = std::make_unique<MECoreActor>(
         SYM_AAPL, oeGateway->getActorId(), mdActor->getActorId(), chActor->getActorId());
-    auto bookMSFT = std::make_unique<OrderBookActor>(
+    auto bookMSFT = std::make_unique<MECoreActor>(
         SYM_MSFT, oeGateway->getActorId(), mdActor->getActorId(), chActor->getActorId());
-    auto bookGOOGL = std::make_unique<OrderBookActor>(
+    auto bookGOOGL = std::make_unique<MECoreActor>(
         SYM_GOOGL, oeGateway->getActorId(), mdActor->getActorId(), chActor->getActorId());
-    auto bookEURO50 = std::make_unique<OrderBookActor>(
+    auto bookEURO50 = std::make_unique<MECoreActor>(
         SYM_EURO50, oeGateway->getActorId(), mdActor->getActorId(), chActor->getActorId());
 
     oeGateway->mapSymbol(SYM_AAPL, bookAAPL->getActorId());
@@ -87,7 +87,7 @@ int main() {
     oeGateway->mapSymbol(SYM_EURO50, bookEURO50->getActorId());
 
     // ── Core 0: FIX Gateway ──────────────────────────────────────
-    auto fixGateway = std::make_unique<FIXGatewayActor>(oeGateway->getActorId(), 9001);
+    auto fixGateway = std::make_unique<FIXAcceptorActor>(oeGateway->getActorId(), 9001);
 
     // ── Core 3: AI Trader ─────────────────────────────────────────
     auto aiTrader = std::make_unique<AITraderActor>(oeGateway->getActorId(), allSymbols);
@@ -98,14 +98,14 @@ int main() {
 
     // ── Print topology ────────────────────────────────────────────
     std::cout << "Actor topology:\n";
-    std::cout << "  Core 0: OEGateway (id=" << oeGateway->getActorId().id
-              << "), FIXGateway (id=" << fixGateway->getActorId().id << ")\n";
+    std::cout << "  Core 0: OEG (id=" << oeGateway->getActorId().id
+              << "), FIXAcceptor (id=" << fixGateway->getActorId().id << ")\n";
     std::cout << "  Core 1: Book AAPL (id=" << bookAAPL->getActorId().id
               << "), MSFT (id=" << bookMSFT->getActorId().id
               << "), GOOGL (id=" << bookGOOGL->getActorId().id
               << "), EURO50 (id=" << bookEURO50->getActorId().id << ")\n";
-    std::cout << "  Core 2: MarketData (id=" << mdActor->getActorId().id << ")\n";
-    std::cout << "  Core 3: ClearingHouse (id=" << chActor->getActorId().id
+    std::cout << "  Core 2: MDG (id=" << mdActor->getActorId().id << ")\n";
+    std::cout << "  Core 3: CH (id=" << chActor->getActorId().id
               << "), AITrader (id=" << aiTrader->getActorId().id << ")\n\n";
 
     std::cout << "Services:\n";

src/net/SocketCompat.hpp

@@ -1,5 +1,5 @@
 #pragma once
-// Cross-platform socket abstraction for FIXGatewayActor
+// Cross-platform socket abstraction for FIXAcceptorActor
 
 #ifdef _WIN32
   #ifndef WIN32_LEAN_AND_MEAN

tests/test_ai_trader.cpp

@@ -3,9 +3,9 @@
 // ════════════════════════════════════════════════════════════════════
 
 #include "actors/AITraderActor.hpp"
-#include "actors/OEGatewayActor.hpp"
-#include "actors/OrderBookActor.hpp"
-#include "actors/MarketDataActor.hpp"
+#include "actors/OEGActor.hpp"
+#include "actors/MECoreActor.hpp"
+#include "actors/MDGActor.hpp"
 #include "actors/ClearingHouseActor.hpp"
 #include <iostream>
 #include <cassert>
@@ -30,18 +30,18 @@ static int testsFailed = 0;
 // ── Tests ─────────────────────────────────────────────────────────
 
 void test_ai_trader_creates() {
-    auto oe = std::make_unique<OEGatewayActor>();
+    auto oe = std::make_unique<OEGActor>();
     std::vector<SymbolIndex_t> syms = {1, 2};
     auto ai = std::make_unique<AITraderActor>(oe->getActorId(), syms);
     ASSERT_TRUE(ai != nullptr);
 }
 
 void test_ai_submits_orders() {
-    auto oe = std::make_unique<OEGatewayActor>();
-    auto md = std::make_unique<MarketDataActor>();
+    auto oe = std::make_unique<OEGActor>();
+    auto md = std::make_unique<MDGActor>();
 
-    auto book1 = std::make_unique<OrderBookActor>(1, oe->getActorId(), md->getActorId());
-    auto book2 = std::make_unique<OrderBookActor>(2, oe->getActorId(), md->getActorId());
+    auto book1 = std::make_unique<MECoreActor>(1, oe->getActorId(), md->getActorId());
+    auto book2 = std::make_unique<MECoreActor>(2, oe->getActorId(), md->getActorId());
     oe->mapSymbol(1, book1->getActorId());
     oe->mapSymbol(2, book2->getActorId());
 
@@ -54,9 +54,9 @@ void test_ai_submits_orders() {
 }
 
 void test_ai_responds_to_book_update() {
-    auto oe = std::make_unique<OEGatewayActor>();
-    auto md = std::make_unique<MarketDataActor>();
-    auto book = std::make_unique<OrderBookActor>(1, oe->getActorId(), md->getActorId());
+    auto oe = std::make_unique<OEGActor>();
+    auto md = std::make_unique<MDGActor>();
+    auto book = std::make_unique<MECoreActor>(1, oe->getActorId(), md->getActorId());
     oe->mapSymbol(1, book->getActorId());
 
     std::vector<SymbolIndex_t> syms = {1};
@@ -76,7 +76,7 @@ void test_ai_responds_to_book_update() {
 }
 
 void test_ai_responds_to_trade() {
-    auto oe = std::make_unique<OEGatewayActor>();
+    auto oe = std::make_unique<OEGActor>();
     std::vector<SymbolIndex_t> syms = {1};
     auto ai = std::make_unique<AITraderActor>(oe->getActorId(), syms);
 
@@ -96,8 +96,8 @@ void test_ai_responds_to_trade() {
 }
 
 void test_ai_with_clearing_house() {
-    auto oe = std::make_unique<OEGatewayActor>();
-    auto md = std::make_unique<MarketDataActor>();
+    auto oe = std::make_unique<OEGActor>();
+    auto md = std::make_unique<MDGActor>();
     auto ch = std::make_unique<ClearingHouseActor>();
 
     for (int i = 0; i < 10; ++i) {
@@ -105,7 +105,7 @@ void test_ai_with_clearing_house() {
                        static_cast<MemberId_t>(i + 1));
     }
 
-    auto book = std::make_unique<OrderBookActor>(
+    auto book = std::make_unique<MECoreActor>(
         1, oe->getActorId(), md->getActorId(), ch->getActorId());
     oe->mapSymbol(1, book->getActorId());
 
@@ -121,13 +121,13 @@ void test_ai_with_clearing_house() {
 }
 
 void test_multiple_symbols() {
-    auto oe = std::make_unique<OEGatewayActor>();
-    auto md = std::make_unique<MarketDataActor>();
+    auto oe = std::make_unique<OEGActor>();
+    auto md = std::make_unique<MDGActor>();
 
     std::vector<SymbolIndex_t> syms = {1, 2, 3, 4};
-    std::vector<std::unique_ptr<OrderBookActor>> books;
+    std::vector<std::unique_ptr<MECoreActor>> books;
     for (auto s : syms) {
-        auto book = std::make_unique<OrderBookActor>(s, oe->getActorId(), md->getActorId());
+        auto book = std::make_unique<MECoreActor>(s, oe->getActorId(), md->getActorId());
         oe->mapSymbol(s, book->getActorId());
         books.push_back(std::move(book));
     }

tests/test_clearing_house.cpp

@@ -3,9 +3,9 @@
 // ════════════════════════════════════════════════════════════════════
 
 #include "actors/ClearingHouseActor.hpp"
-#include "actors/OrderBookActor.hpp"
-#include "actors/OEGatewayActor.hpp"
-#include "actors/MarketDataActor.hpp"
+#include "actors/MECoreActor.hpp"
+#include "actors/OEGActor.hpp"
+#include "actors/MDGActor.hpp"
 #include <iostream>
 #include <cassert>
 
@@ -142,14 +142,14 @@ void test_leaderboard_sorted() {
 }
 
 void test_trade_with_clearing_pipe() {
-    auto oe = std::make_unique<OEGatewayActor>();
-    auto md = std::make_unique<MarketDataActor>();
+    auto oe = std::make_unique<OEGActor>();
+    auto md = std::make_unique<MDGActor>();
     auto ch = std::make_unique<ClearingHouseActor>();
 
     ch->mapSession(1, 1);
     ch->mapSession(2, 2);
 
-    auto book = std::make_unique<OrderBookActor>(
+    auto book = std::make_unique<MECoreActor>(
         1, oe->getActorId(), md->getActorId(), ch->getActorId());
     oe->mapSymbol(1, book->getActorId());
 

tests/test_fix_gateway.cpp

@@ -1,11 +1,11 @@
 // ════════════════════════════════════════════════════════════════════
-// FIXGatewayActor tests — protocol parsing and symbol mapping
+// FIXAcceptorActor tests — protocol parsing and symbol mapping
 // ════════════════════════════════════════════════════════════════════
 
-#include "actors/FIXGatewayActor.hpp"
-#include "actors/OEGatewayActor.hpp"
-#include "actors/OrderBookActor.hpp"
-#include "actors/MarketDataActor.hpp"
+#include "actors/FIXAcceptorActor.hpp"
+#include "actors/OEGActor.hpp"
+#include "actors/MECoreActor.hpp"
+#include "actors/MDGActor.hpp"
 #include <iostream>
 #include <cassert>
 #include <string>
@@ -30,23 +30,23 @@ static int testsFailed = 0;
 // ── Tests ─────────────────────────────────────────────────────────
 
 void test_symbol_from_string() {
-    ASSERT_EQ(FIXGatewayActor::symbolFromString("AAPL"), 1u);
-    ASSERT_EQ(FIXGatewayActor::symbolFromString("MSFT"), 2u);
-    ASSERT_EQ(FIXGatewayActor::symbolFromString("GOOGL"), 3u);
-    ASSERT_EQ(FIXGatewayActor::symbolFromString("EURO50"), 4u);
+    ASSERT_EQ(FIXAcceptorActor::symbolFromString("AAPL"), 1u);
+    ASSERT_EQ(FIXAcceptorActor::symbolFromString("MSFT"), 2u);
+    ASSERT_EQ(FIXAcceptorActor::symbolFromString("GOOGL"), 3u);
+    ASSERT_EQ(FIXAcceptorActor::symbolFromString("EURO50"), 4u);
 }
 
 void test_symbol_to_string() {
-    ASSERT_TRUE(FIXGatewayActor::symbolToString(1) == "AAPL");
-    ASSERT_TRUE(FIXGatewayActor::symbolToString(2) == "MSFT");
-    ASSERT_TRUE(FIXGatewayActor::symbolToString(3) == "GOOGL");
-    ASSERT_TRUE(FIXGatewayActor::symbolToString(4) == "EURO50");
-    ASSERT_TRUE(FIXGatewayActor::symbolToString(99) == "99");
+    ASSERT_TRUE(FIXAcceptorActor::symbolToString(1) == "AAPL");
+    ASSERT_TRUE(FIXAcceptorActor::symbolToString(2) == "MSFT");
+    ASSERT_TRUE(FIXAcceptorActor::symbolToString(3) == "GOOGL");
+    ASSERT_TRUE(FIXAcceptorActor::symbolToString(4) == "EURO50");
+    ASSERT_TRUE(FIXAcceptorActor::symbolToString(99) == "99");
 }
 
 void test_fix_gateway_creates() {
-    auto oe = std::make_unique<OEGatewayActor>();
-    auto fix = std::make_unique<FIXGatewayActor>(oe->getActorId(), 19010);
+    auto oe = std::make_unique<OEGActor>();
+    auto fix = std::make_unique<FIXAcceptorActor>(oe->getActorId(), 19010);
     ASSERT_TRUE(fix->isRunning());
     ASSERT_EQ(fix->clientCount(), 0);
     fix->stop();
@@ -54,9 +54,9 @@ void test_fix_gateway_creates() {
 }
 
 void test_oe_gateway_routes_new_order_event() {
-    auto oe = std::make_unique<OEGatewayActor>();
-    auto md = std::make_unique<MarketDataActor>();
-    auto book = std::make_unique<OrderBookActor>(1, oe->getActorId(), md->getActorId());
+    auto oe = std::make_unique<OEGActor>();
+    auto md = std::make_unique<MDGActor>();
+    auto book = std::make_unique<MECoreActor>(1, oe->getActorId(), md->getActorId());
     oe->mapSymbol(1, book->getActorId());
 
     NewOrderEvent evt(5001, 1, Side::Buy, OrderType::Limit, TimeInForce::Day,
@@ -68,12 +68,12 @@ void test_oe_gateway_routes_new_order_event() {
 }
 
 void test_exec_report_forwarding() {
-    auto oe = std::make_unique<OEGatewayActor>();
-    auto md = std::make_unique<MarketDataActor>();
-    auto book = std::make_unique<OrderBookActor>(1, oe->getActorId(), md->getActorId());
+    auto oe = std::make_unique<OEGActor>();
+    auto md = std::make_unique<MDGActor>();
+    auto book = std::make_unique<MECoreActor>(1, oe->getActorId(), md->getActorId());
     oe->mapSymbol(1, book->getActorId());
 
-    auto fix = std::make_unique<FIXGatewayActor>(oe->getActorId(), 19011);
+    auto fix = std::make_unique<FIXAcceptorActor>(oe->getActorId(), 19011);
     oe->addExecReportSubscriber(fix->getActorId());
 
     oe->submitNewOrder(1, 1, Side::Buy, OrderType::Limit,

tests/test_matching_engine.cpp

@@ -6,9 +6,9 @@
 // execution reports, and market data snapshots.
 // ════════════════════════════════════════════════════════════════════
 
-#include "actors/OrderBookActor.hpp"
-#include "actors/OEGatewayActor.hpp"
-#include "actors/MarketDataActor.hpp"
+#include "actors/MECoreActor.hpp"
+#include "actors/OEGActor.hpp"
+#include "actors/MDGActor.hpp"
 #include <iostream>
 #include <cassert>
 
@@ -32,16 +32,16 @@ static int testsFailed = 0;
 // ── Test fixtures ──────────────────────────────────────────────────
 
 struct Fixture {
-    std::unique_ptr<OEGatewayActor>  oeGateway;
-    std::unique_ptr<MarketDataActor> mdActor;
-    std::unique_ptr<OrderBookActor>  book;
+    std::unique_ptr<OEGActor>  oeGateway;
+    std::unique_ptr<MDGActor> mdActor;
+    std::unique_ptr<MECoreActor>  book;
     static constexpr SymbolIndex_t SYM = 1;
     static constexpr SessionId_t SESS = 1;
 
     Fixture() {
-        oeGateway = std::make_unique<OEGatewayActor>();
-        mdActor   = std::make_unique<MarketDataActor>();
-        book      = std::make_unique<OrderBookActor>(
+        oeGateway = std::make_unique<OEGActor>();
+        mdActor   = std::make_unique<MDGActor>();
+        book      = std::make_unique<MECoreActor>(
             SYM, oeGateway->getActorId(), mdActor->getActorId());
         oeGateway->mapSymbol(SYM, book->getActorId());
     }

tests/test_orderbook.cpp

@@ -5,7 +5,7 @@
 // price-time priority matching with fixed-point prices.
 // ════════════════════════════════════════════════════════════════════
 
-#include "common/OrderBook.hpp"
+#include "common/Book.hpp"
 #include <iostream>
 #include <cassert>
 #include <vector>
@@ -57,7 +57,7 @@ static auto onExec  = [](const ExecutionReport& r) { reports.push_back(r); };
 // ── Tests ──────────────────────────────────────────────────────────
 
 void test_limit_buy_rests_on_empty_book() {
-    OrderBook book(1);
+    Book book(1);
     resetCallbacks();
 
     auto order = makeOrder(Side::Buy, OrderType::Limit, TimeInForce::Day, 100.0, 50);
@@ -70,7 +70,7 @@ void test_limit_buy_rests_on_empty_book() {
 }
 
 void test_limit_sell_rests_on_empty_book() {
-    OrderBook book(1);
+    Book book(1);
     resetCallbacks();
 
     auto order = makeOrder(Side::Sell, OrderType::Limit, TimeInForce::Day, 100.0, 50);
@@ -82,7 +82,7 @@ void test_limit_sell_rests_on_empty_book() {
 }
 
 void test_exact_match() {
-    OrderBook book(1);
+    Book book(1);
     resetCallbacks();
 
     auto sell = makeOrder(Side::Sell, OrderType::Limit, TimeInForce::Day, 50.0, 100);
@@ -99,7 +99,7 @@ void test_exact_match() {
 }
 
 void test_partial_fill() {
-    OrderBook book(1);
+    Book book(1);
     resetCallbacks();
 
     auto sell = makeOrder(Side::Sell, OrderType::Limit, TimeInForce::Day, 50.0, 100);
@@ -118,7 +118,7 @@ void test_partial_fill() {
 }
 
 void test_price_priority() {
-    OrderBook book(1);
+    Book book(1);
     resetCallbacks();
 
     // Two sells at different prices
@@ -138,7 +138,7 @@ void test_price_priority() {
 }
 
 void test_time_priority() {
-    OrderBook book(1);
+    Book book(1);
     resetCallbacks();
 
     // Two sells at same price — first should match first (FIFO)
@@ -156,7 +156,7 @@ void test_time_priority() {
 }
 
 void test_market_order_matches_any_price() {
-    OrderBook book(1);
+    Book book(1);
     resetCallbacks();
 
     auto sell = makeOrder(Side::Sell, OrderType::Limit, TimeInForce::Day, 999.99, 50);
@@ -171,7 +171,7 @@ void test_market_order_matches_any_price() {
 }
 
 void test_market_order_does_not_rest() {
-    OrderBook book(1);
+    Book book(1);
     resetCallbacks();
 
     auto buy = makeOrder(Side::Buy, OrderType::Market, TimeInForce::IOC, 0, 50);
@@ -183,7 +183,7 @@ void test_market_order_does_not_rest() {
 }
 
 void test_ioc_partial_fill_cancel_rest() {
-    OrderBook book(1);
+    Book book(1);
     resetCallbacks();
 
     auto sell = makeOrder(Side::Sell, OrderType::Limit, TimeInForce::Day, 50.0, 30);
@@ -199,7 +199,7 @@ void test_ioc_partial_fill_cancel_rest() {
 }
 
 void test_fok_rejected_when_insufficient() {
-    OrderBook book(1);
+    Book book(1);
     resetCallbacks();
 
     auto sell = makeOrder(Side::Sell, OrderType::Limit, TimeInForce::Day, 50.0, 30);
@@ -215,7 +215,7 @@ void test_fok_rejected_when_insufficient() {
 }
 
 void test_fok_fills_when_sufficient() {
-    OrderBook book(1);
+    Book book(1);
     resetCallbacks();
 
     auto sell = makeOrder(Side::Sell, OrderType::Limit, TimeInForce::Day, 50.0, 100);
@@ -231,7 +231,7 @@ void test_fok_fills_when_sufficient() {
 }
 
 void test_cancel_order() {
-    OrderBook book(1);
+    Book book(1);
     resetCallbacks();
 
     auto sell = makeOrder(Side::Sell, OrderType::Limit, TimeInForce::Day, 50.0, 100);
@@ -245,14 +245,14 @@ void test_cancel_order() {
 }
 
 void test_cancel_nonexistent() {
-    OrderBook book(1);
+    Book book(1);
     ExecutionReport rpt{};
     bool ok = book.cancelOrder(9999, rpt);
     ASSERT_TRUE(!ok);
 }
 
 void test_multi_level_sweep() {
-    OrderBook book(1);
+    Book book(1);
     resetCallbacks();
 
     // Three sell levels

tests/test_threaded_engine.cpp

@@ -1,7 +1,7 @@
 #include "engine/SimplxShim.hpp"
-#include "actors/OrderBookActor.hpp"
-#include "actors/OEGatewayActor.hpp"
-#include "actors/MarketDataActor.hpp"
+#include "actors/MECoreActor.hpp"
+#include "actors/OEGActor.hpp"
+#include "actors/MDGActor.hpp"
 #include <iostream>
 #include <cassert>
 #include <atomic>
@@ -29,8 +29,8 @@ static int testsFailed = 0;
 
 void test_engine_multi_core_creation() {
     Engine::StartSequence seq;
-    seq.addActor<OEGatewayActor>(0);
-    seq.addActor<MarketDataActor>(2);
+    seq.addActor<OEGActor>(0);
+    seq.addActor<MDGActor>(2);
     Engine engine(seq);
 
     ASSERT_EQ(engine.coreCount(), 2UL);
@@ -39,12 +39,12 @@ void test_engine_multi_core_creation() {
 // ── Test: cross-core event delivery via mailbox ────────────────────
 
 void test_cross_core_event_delivery() {
-    auto oeGateway = std::make_unique<OEGatewayActor>();
-    auto mdActor   = std::make_unique<MarketDataActor>();
+    auto oeGateway = std::make_unique<OEGActor>();
+    auto mdActor   = std::make_unique<MDGActor>();
 
     // Manually assign to different cores
     constexpr SymbolIndex_t SYM = 1;
-    auto book = std::make_unique<OrderBookActor>(
+    auto book = std::make_unique<MECoreActor>(
         SYM, oeGateway->getActorId(), mdActor->getActorId());
 
     oeGateway->mapSymbol(SYM, book->getActorId());
@@ -60,15 +60,15 @@ void test_cross_core_event_delivery() {
 // ── Test: threaded engine runs matching across cores ───────────────
 
 struct ThreadedFixture {
-    OEGatewayActor* oeGateway = nullptr;
-    MarketDataActor* mdActor  = nullptr;
+    OEGActor* oeGateway = nullptr;
+    MDGActor* mdActor  = nullptr;
     std::unique_ptr<Engine> engine;
 
     ThreadedFixture() {
         Engine::StartSequence seq;
-        seq.addActor<OEGatewayActor>(0);
-        seq.addActor<MarketDataActor>(2);
-        seq.addActor<OrderBookActor>(1,
+        seq.addActor<OEGActor>(0);
+        seq.addActor<MDGActor>(2);
+        seq.addActor<MECoreActor>(1,
             SymbolIndex_t(1), ActorId{1, 0}, ActorId{2, 2});
 
         engine = std::make_unique<Engine>(seq);
@@ -77,11 +77,11 @@ struct ThreadedFixture {
 
 void test_threaded_matching() {
     // Use synchronous mode for deterministic testing
-    auto oeGateway = std::make_unique<OEGatewayActor>();
-    auto mdActor   = std::make_unique<MarketDataActor>();
+    auto oeGateway = std::make_unique<OEGActor>();
+    auto mdActor   = std::make_unique<MDGActor>();
 
     constexpr SymbolIndex_t SYM = 1;
-    auto book = std::make_unique<OrderBookActor>(
+    auto book = std::make_unique<MECoreActor>(
         SYM, oeGateway->getActorId(), mdActor->getActorId());
 
     oeGateway->mapSymbol(SYM, book->getActorId());
@@ -124,9 +124,9 @@ void test_mailbox_concurrent_enqueue() {
 
 void test_engine_core_assignment() {
     Engine::StartSequence seq;
-    seq.addActor<OEGatewayActor>(0);
-    seq.addActor<MarketDataActor>(1);
-    seq.addActor<OEGatewayActor>(2);
+    seq.addActor<OEGActor>(0);
+    seq.addActor<MDGActor>(1);
+    seq.addActor<OEGActor>(2);
     Engine engine(seq);
 
     ASSERT_EQ(engine.coreCount(), 3UL);
@@ -136,11 +136,11 @@ void test_engine_core_assignment() {
 
 void test_sync_backward_compat() {
     // Actors created outside Engine should work exactly as before
-    auto oeGateway = std::make_unique<OEGatewayActor>();
-    auto mdActor   = std::make_unique<MarketDataActor>();
+    auto oeGateway = std::make_unique<OEGActor>();
+    auto mdActor   = std::make_unique<MDGActor>();
 
     constexpr SymbolIndex_t SYM = 1;
-    auto book = std::make_unique<OrderBookActor>(
+    auto book = std::make_unique<MECoreActor>(
         SYM, oeGateway->getActorId(), mdActor->getActorId());
 
     oeGateway->mapSymbol(SYM, book->getActorId());