diff --git a/CLAUDE.md b/CLAUDE.md
index 48ac33c..916f5de 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -97,18 +97,43 @@ The project uses a **hierarchical documentation system** in `/docs/`:
 ## Key Technical Concepts
 
 ### Core Interface Architecture (COMPLETED - PHASE 1)
-- **Quadruple Interface Pattern**: IEngine, IModuleSystem, IModule, IIO + ITaskScheduler
+- **Complete Interface Set**: IEngine, IModuleSystem, IModule, IIO, ITaskScheduler, IDataTree, IDataNode, ICoordinationModule
 - **CRITICAL**: **Core interfaces are IMMUTABLE** - Never modify once finalized
+- **Configuration System**: IDataTree/IDataNode for hierarchical data-driven development with const references
+- **Coordination System**: ICoordinationModule as global orchestrator (first launched, last shutdown)
+- **Task Delegation**: ITaskScheduler for module → execution system delegation (multithreading)
 - **Autonomous Modules**: Small (200-300 lines) hot-reloadable modules (.so files)
 - **Claude Code Optimized**: Each module is a micro-context for AI development
 - **Performance Targets**: V1 Client 30+ fps, V2 Client 60+ fps, V1 Server 10+ players, V2 Server 100+ players
 
 ### Interface Specifications (NEVER MODIFY THESE)
-- **IEngine**: Engine orchestration, module loading, client/coordinator socket management
-- **IModuleSystem**: Execution strategy + task scheduling (inherits ITaskScheduler)
-- **IModule**: Pure business logic + pub/sub communication + task delegation
+- **ICoordinationModule**: Global system orchestrator, gameconfig.json management, module deployment topology
+- **IEngine**: Local engine orchestration, module loading, client/coordinator socket management
+- **IModuleSystem**: Execution strategy implementation (Sequential → Threaded → Cluster)
+- **IModule**: Pure business logic + pub/sub communication (**BREAKING CHANGES** - see below)
 - **IIO**: Pull-based pub/sub with low-frequency batching and health monitoring
-- **ITaskScheduler**: Task delegation interface for module → execution system
+- **ITaskScheduler**: Task delegation interface for module → execution system (multithreading)
+- **IDataTree**: Configuration tree container with manual hot-reload capabilities
+- **IDataNode**: Hierarchical data nodes with pattern matching and property queries (**const methods**)
+
+### BREAKING CHANGES in IModule Interface
+```cpp
+// OLD Interface (DEPRECATED)
+virtual void initialize(const json& config, IIO* io, ITaskScheduler* scheduler) = 0;
+virtual bool isHealthy() = 0;
+
+// NEW Interface (CURRENT)
+virtual void setConfiguration(const IDataNode& configNode, IIO* io, ITaskScheduler* scheduler) = 0;
+virtual const IDataNode& getConfiguration() = 0;
+virtual json getHealthStatus() = 0;  // Detailed JSON instead of bool
+// initialize() method REMOVED
+```
+
+### Configuration Immutability System
+- **const IDataNode&** references prevent modules from modifying configuration
+- **Single source of truth**: gameconfig.json loaded via IDataTree
+- **Hot-reload**: CoordinationModule propagates config changes to all modules
+- **Type safety**: All IDataNode getters are const methods
 
 ### Module Frequencies & Isolation
 - **ProductionModule**: 60Hz (frame-perfect factory operations)
@@ -272,7 +297,7 @@ cmake --build build               # ALL debugging tools active by default
 ## Claude Code Development Practices
 
 ### Interface Management (ABSOLUTELY CRITICAL)
-- **IMMUTABLE INTERFACES**: Core interfaces (IEngine, IModuleSystem, IModule, IIO, ITaskScheduler) are FROZEN
+- **IMMUTABLE INTERFACES**: Core interfaces (IEngine, IModuleSystem, IModule, IIO, ITaskScheduler, IDataTree, IDataNode) are FROZEN
 - **NEVER MODIFY**: Once interfaces are finalized, they become the architectural foundation
 - **Extension Only**: New functionality via new implementations, not interface changes
 - **Breaking Changes**: Modifying core interfaces breaks ALL existing modules and systems
@@ -363,4 +388,27 @@ The project includes 16 C++ libraries via FetchContent:
 
 **DEVELOPMENT WORKFLOW**: ✅ **BATTLE-TESTED** - AddressSanitizer + GDB integration for instant bug detection.
 
-**Next Phase**: Integration of IUI system with core modular architecture and hot-reload capabilities.
\ No newline at end of file
+**CONFIGURATION SYSTEM**: ✅ **INTERFACES COMPLETE** - Comprehensive IDataTree configuration system for data-driven gameplay.
+- **GameConfig Source**: Single `gameconfig.json` file containing all game configuration and module deployment topology
+- **Hierarchical Data**: Tree structure where each node can have both children AND its own data blob
+- **Advanced Querying**: Pattern matching with wildcards, property-based lambda predicates
+- **Type-Safe Access**: Getters with defaults for int/double/string/bool properties
+- **Hash Validation**: SHA256 hashing for data integrity and synchronization
+- **Manual Hot-Reload**: Check for changes and reload on demand with callbacks
+- **Module Distribution**: gameconfig.json defines which modules to load and where to deploy them
+
+## 🎯 **Current Status - INTERFACES COMPLETE & CLEAN**
+
+**CORE INTERFACES**: ✅ **ALL COMPLETE** - Complete interface set with proper file organization:
+- ✅ **ICoordinationModule.h** - Global orchestrator with detailed startup/shutdown sequences
+- ✅ **ITaskScheduler.h** - **NEW FILE** with comprehensive multithreading delegation documentation
+- ✅ **IModule.h** - BREAKING CHANGES implemented with const IDataNode& configuration
+- ✅ **IDataNode.h** - All methods const for immutability enforcement
+- ✅ **IEngine.h, IModuleSystem.h, IIO.h** - Recovered and cleaned from duplications
+- ✅ **IDataTree.h, DataTreeFactory.h** - Configuration system foundation
+
+**ARCHITECTURE DOCUMENTED**: ✅ **COMPLETE** - Full system flow and coordination patterns documented
+
+**BREAKING CHANGES**: ✅ **IMPLEMENTED** - IModule interface modernized with configuration immutability
+
+**Next Phase**: Implementation of JSONDataTree concrete classes and example gameconfig.json for testing.
\ No newline at end of file
diff --git a/TODO.md b/TODO.md
index ace57e3..0ac6a41 100644
--- a/TODO.md
+++ b/TODO.md
@@ -422,7 +422,7 @@
 ---
 
 ## Notes
-- **Architecture Status**: Transitioning from 10 engines to modular system
+- **Architecture Status**: Modular system with complete interface specifications
 - **Documentation**: See `docs/01-architecture/architecture-modulaire.md` for complete specification
 - **Claude Code Optimization**: Each module = micro-context for AI development
 - **Exception**: ProductionModule (Belt+Inserter+Factory) requires 500-800 lines for performance
diff --git a/docs/01-architecture/architecture-modulaire.md b/docs/01-architecture/architecture-modulaire.md
index e7141d7..8f196dd 100644
--- a/docs/01-architecture/architecture-modulaire.md
+++ b/docs/01-architecture/architecture-modulaire.md
@@ -4,15 +4,17 @@
 
 L'architecture modulaire Warfactory transforme le développement de jeux complexes en utilisant une approche **micro-modules** optimisée pour Claude Code. Chaque module est un micro-contexte de 200-300 lignes de logique métier pure.
 
-## Triple Interface Pattern
+## Core Interface Architecture
 
 ### Architecture Fondamentale
 
 ```cpp
-IEngine        → Orchestration et coordination
-IModuleSystem  → Stratégies d'exécution
-IModule        → Logique métier pure
-IIO            → Communication et transport
+ICoordinationModule → Orchestrateur global système
+IEngine            → Orchestration locale
+IModuleSystem      → Stratégies d'exécution
+IModule            → Logique métier pure
+IIO                → Communication et transport
+ITaskScheduler     → Délégation de tâches
 ```
 
 ### IEngine - Orchestration
diff --git a/docs/01-architecture/architecture-technique.md b/docs/01-architecture/architecture-technique.md
index 745bab2..423566e 100644
--- a/docs/01-architecture/architecture-technique.md
+++ b/docs/01-architecture/architecture-technique.md
@@ -8,17 +8,35 @@
 
 ## Architecture Système
 
-### Triple Interface Pattern (Architecture Révolutionnaire)
+### Core Interface Architecture
 
-**NOUVELLE ARCHITECTURE MODULAIRE** - Remplace l'ancienne architecture 10 engines par un système modulaire optimisé pour le développement avec Claude Code.
+**ARCHITECTURE MODULAIRE** - Système modulaire optimisé pour le développement avec Claude Code.
 
-#### Les 4 Interfaces Fondamentales
+#### Les 5 Interfaces Fondamentales
 
 ```cpp
-IEngine        → Coordination générale (DebugEngine → HighPerfEngine → DataOrientedEngine)
-IModuleSystem  → Stratégie d'exécution (Sequential → Threaded → Multithread → Cluster)
-IModule        → Logique métier pure (TankModule.so, EconomyModule.so, FactoryModule.so)
-IIO            → Communication (IntraIO → LocalIO → NetworkIO)
+ICoordinationModule → Orchestrateur global système (MainServer, déploiement, config)
+IEngine            → Coordination locale (DebugEngine → HighPerfEngine → DataOrientedEngine)
+IModuleSystem      → Stratégie d'exécution (Sequential → Threaded → Multithread → Cluster)
+IModule            → Logique métier pure (TankModule.so, EconomyModule.so, FactoryModule.so)
+IIO                → Communication (IntraIO → LocalIO → NetworkIO)
+```
+
+#### Architecture de Déploiement Global
+
+```
+MainServer Process:
+├── CoordinationModule (Global Orchestrator)
+│   ├── Loads gameconfig.json via IDataTree
+│   ├── Manages local IEngine + modules
+│   └── Launches remote servers + engines
+├── Local IEngine (manages local modules)
+│   ├── IModuleSystem (Sequential/Threaded/etc.)
+│   └── Local Modules (.so files)
+└── Remote Servers (launched by coordination)
+    ├── Remote IEngine (manages remote modules)
+    ├── IModuleSystem (execution strategy)
+    └── Remote Modules (.so files)
 ```
 
 #### Séparation des Responsabilités
@@ -34,12 +52,21 @@ IIO            → Communication (IntraIO → LocalIO → NetworkIO)
 - MultithreadedModuleSystem : Pool de threads pour tasks
 - ClusterModuleSystem : Distribution sur plusieurs machines
 
-**IModule** : Logique métier pure
+**ICoordinationModule** : Orchestrateur global système
+- Premier module lancé, dernier fermé
+- Charge gameconfig.json via IDataTree
+- Déploie modules selon topologie (local/distant)
+- Synchronise configurations entre tous les modules
+
+**IModule** : Logique métier pure (BREAKING CHANGES)
 ```cpp
 class IModule {
     virtual json process(const json& input) = 0;  // PURE FUNCTION
-    virtual void initialize(const json& config) = 0;
+    virtual void setConfiguration(const IDataNode& configNode, IIO* io, ITaskScheduler* scheduler) = 0;  // NEW
+    virtual const IDataNode& getConfiguration() = 0;  // NEW
+    virtual json getHealthStatus() = 0;  // NEW - detailed JSON instead of bool
     virtual void shutdown() = 0;
+    // initialize() method REMOVED
 };
 ```
 
diff --git a/docs/04-reference/INTEGRATION-MASTER-LIST.md b/docs/04-reference/INTEGRATION-MASTER-LIST.md
new file mode 100644
index 0000000..68ba3db
--- /dev/null
+++ b/docs/04-reference/INTEGRATION-MASTER-LIST.md
@@ -0,0 +1,395 @@
+# INTEGRATION MASTER LIST
+
+Complete technical specifications catalog for the Warfactory project.
+
+## Global Architecture Overview
+
+### System Orchestration Flow
+```
+MainServer Process:
+├── CoordinationModule (Global Orchestrator)
+│   ├── Loads gameconfig.json via IDataTree
+│   ├── Launches local IEngine + modules
+│   └── Launches remote servers + engines
+├── Local IEngine (manages local modules)
+│   ├── IModuleSystem (execution strategy)
+│   └── Local Modules (.so files)
+└── Remote Servers (launched by coordination)
+    ├── Remote IEngine (manages remote modules)
+    ├── IModuleSystem (execution strategy)
+    └── Remote Modules (.so files)
+```
+
+### Startup Sequence
+1. **MainServer** starts and launches **CoordinationModule**
+2. **CoordinationModule** calls `startNewGame("gameconfig.json")`
+3. **Config Loading**: IDataTree loads and parses gameconfig.json
+4. **Deployment Analysis**: Parse deployment section to determine module topology
+5. **Local Deployment**: Deploy modules with `target: "local"` to local IEngine
+6. **Remote Deployment**: Launch remote servers and deploy modules with `target: "server:IP"`
+7. **Synchronization**: All modules receive their configuration via `setConfiguration()`
+8. **Game Ready**: Return control to user interface
+
+### Module Lifecycle with New Configuration System
+```cpp
+// Old way (DEPRECATED)
+module->initialize(json_config, io, scheduler);
+
+// New way (CURRENT)
+const IDataNode& config = configTree->getNode("modules/production");
+module->setConfiguration(config, io, scheduler);  // const ref, no copies
+
+// Health monitoring
+json health = module->getHealthStatus();
+// Returns: {"status": "healthy", "last_process_time_ms": 1.2, "memory_usage_mb": 45}
+```
+
+## Core Interface System
+
+### Engine Interfaces (IMMUTABLE)
+- **IEngine**: Engine orchestration, module loading, client/coordinator socket management
+- **IModuleSystem**: Execution strategy + task scheduling (inherits ITaskScheduler)
+- **IModule**: Pure business logic + pub/sub communication + task delegation (**BREAKING CHANGES**)
+- **IIO**: Pull-based pub/sub with low-frequency batching and health monitoring
+- **ITaskScheduler**: Task delegation interface for module → execution system
+
+### Configuration System (IMMUTABLE)
+- **IDataTree**: Configuration tree container with manual hot-reload capabilities
+- **IDataNode**: Hierarchical data nodes with pattern matching and property queries (**const methods**)
+- **DataTreeFactory**: Factory pattern for flexible data source creation
+
+### Coordination System (NEW)
+- **ICoordinationModule**: Global system orchestrator and main game lifecycle manager
+
+## GameConfig.json Architecture
+
+### Central Configuration System
+The entire game system is configured through a single **`gameconfig.json`** file that serves as the master configuration:
+
+```json
+{
+  "game": {
+    "name": "Warfactory Game Session",
+    "version": "1.0.0",
+    "save_path": "./saves/game_001"
+  },
+  "deployment": {
+    "modules": [
+      {
+        "id": "production_main",
+        "type": "ProductionModule",
+        "path": "./modules/production.so",
+        "target": "local",
+        "config_path": "modules/production"
+      },
+      {
+        "id": "economy_central",
+        "type": "EconomyModule",
+        "path": "./modules/economy.so",
+        "target": "server:192.168.1.100:8080",
+        "config_path": "modules/economy"
+      },
+      {
+        "id": "tank_combat",
+        "type": "TankModule",
+        "path": "./modules/tank.so",
+        "target": "cluster:combat_nodes",
+        "config_path": "modules/tank"
+      }
+    ]
+  },
+  "modules": {
+    "production": {
+      "frequency": "60Hz",
+      "belt_speed": 2.5,
+      "inserter_capacity": 12
+    },
+    "economy": {
+      "frequency": "0.1Hz",
+      "inflation_rate": 0.02,
+      "market_volatility": 0.15
+    },
+    "tank": {
+      "targeting_frequency": "60Hz",
+      "movement_frequency": "30Hz",
+      "tactical_frequency": "1Hz"
+    }
+  }
+}
+```
+
+### Configuration Flow
+1. **CoordinationModule** loads `gameconfig.json` via IDataTree
+2. **Deployment section** defines module topology and distribution
+3. **Modules section** contains hierarchical configuration for each module type
+4. **Hot-reload** updates propagated to all deployed modules automatically
+
+### CoordinationModule Deployment Logic
+```cpp
+// Example deployment process
+void CoordinationModule::deployModule(const std::string& moduleInstanceId) {
+    // 1. Get module configuration from gameconfig.json
+    const IDataNode& deployConfig = configTree->getNode("deployment/modules");
+    const IDataNode* moduleConfig = deployConfig.getFirstChildByName(moduleInstanceId);
+
+    // 2. Determine deployment target
+    std::string target = moduleConfig->getString("target");
+    std::string modulePath = moduleConfig->getString("path");
+    std::string configPath = moduleConfig->getString("config_path");
+
+    // 3. Get module-specific configuration
+    const IDataNode& moduleSettings = configTree->getNode("modules/" + configPath);
+
+    // 4. Deploy based on target
+    if (target == "local") {
+        localEngine->getModuleSystem()->loadModule(modulePath, moduleSettings);
+    } else if (target.startswith("server:")) {
+        deployToRemoteServer(target, modulePath, moduleSettings);
+    }
+}
+```
+
+## IDataTree Configuration System Specifications
+
+### Core Architecture
+```cpp
+namespace warfactory {
+    class IDataTree {
+        // Tree access
+        virtual std::unique_ptr<IDataNode> getRoot() = 0;
+        virtual std::unique_ptr<IDataNode> getNode(const std::string& path) = 0;
+
+        // Manual hot-reload
+        virtual bool checkForChanges() = 0;
+        virtual bool reloadIfChanged() = 0;
+        virtual void onTreeReloaded(std::function<void()> callback) = 0;
+
+        // Metadata
+        virtual std::string getType() = 0;
+    };
+}
+```
+
+### IDataNode Capabilities
+```cpp
+namespace warfactory {
+    class IDataNode {
+        // Tree navigation
+        virtual std::unique_ptr<IDataNode> getChild(const std::string& name) = 0;
+        virtual std::vector<std::string> getChildNames() = 0;
+        virtual bool hasChildren() = 0;
+
+        // Exact search in children
+        virtual std::vector<IDataNode*> getChildrenByName(const std::string& name) = 0;
+        virtual bool hasChildrenByName(const std::string& name) const = 0;
+        virtual IDataNode* getFirstChildByName(const std::string& name) = 0;
+
+        // Pattern matching search (deep search in whole subtree)
+        virtual std::vector<IDataNode*> getChildrenByNameMatch(const std::string& pattern) = 0;
+        virtual bool hasChildrenByNameMatch(const std::string& pattern) const = 0;
+        virtual IDataNode* getFirstChildByNameMatch(const std::string& pattern) = 0;
+
+        // Query by properties
+        virtual std::vector<IDataNode*> queryByProperty(const std::string& propName,
+                                                       const std::function<bool(const json&)>& predicate) = 0;
+
+        // Node's own data
+        virtual json getData() = 0;
+        virtual bool hasData() = 0;
+        virtual void setData(const json& data) = 0;
+
+        // Typed data access by property name
+        virtual std::string getString(const std::string& name, const std::string& defaultValue = "") = 0;
+        virtual int getInt(const std::string& name, int defaultValue = 0) = 0;
+        virtual double getDouble(const std::string& name, double defaultValue = 0.0) = 0;
+        virtual bool getBool(const std::string& name, bool defaultValue = false) = 0;
+        virtual bool hasProperty(const std::string& name) = 0;
+
+        // Hash system for validation & synchro
+        virtual std::string getDataHash() = 0;
+        virtual std::string getTreeHash() = 0;
+        virtual std::string getSubtreeHash(const std::string& childPath) = 0;
+
+        // Metadata
+        virtual std::string getPath() = 0;
+        virtual std::string getName() = 0;
+        virtual std::string getNodeType() = 0;
+    };
+}
+```
+
+### Configuration Usage Patterns
+
+#### Hierarchical Data Access
+```cpp
+// Access nested configuration
+std::unique_ptr<IDataTree> tree = DataTreeFactory::create("json", "config/vehicles.json");
+std::unique_ptr<IDataNode> tank = tree->getNode("vehicles/tanks/heavy/model5");
+
+// Get properties with type safety
+int armor = tank->getInt("armor", 100);
+double speed = tank->getDouble("speed", 30.0);
+std::string name = tank->getString("display_name", "Unknown Tank");
+```
+
+#### Pattern Matching Search
+```cpp
+// Find all components
+std::vector<IDataNode*> components = root->getChildrenByNameMatch("component*");
+
+// Find all heavy variants
+std::vector<IDataNode*> heavyUnits = root->getChildrenByNameMatch("*heavy*");
+
+// Find specific models
+std::vector<IDataNode*> models = root->getChildrenByNameMatch("model_*");
+```
+
+#### Property-Based Queries
+```cpp
+// Find all tanks with armor > 150
+std::vector<IDataNode*> heavyTanks = root->queryByProperty("armor", [](const json& val) {
+    return val.is_number() && val.get<int>() > 150;
+});
+
+// Find all vehicles with specific role
+std::vector<IDataNode*> scouts = root->queryByProperty("role", [](const json& val) {
+    return val.is_string() && val.get<std::string>() == "scout";
+});
+```
+
+#### Hot-Reload Workflow
+```cpp
+// Manual hot-reload check
+if (tree->checkForChanges()) {
+    if (tree->reloadIfChanged()) {
+        // Tree was reloaded - update dependent systems
+        updateGameContent();
+    }
+}
+
+// Register reload callback
+tree->onTreeReloaded([]() {
+    std::cout << "Configuration reloaded - updating systems\n";
+    notifyAllModules();
+});
+```
+
+### Hash-Based Validation
+```cpp
+// Validate specific data integrity
+std::string nodeHash = node->getDataHash();
+std::string previousHash = loadStoredHash();
+if (nodeHash != previousHash) {
+    // Data has changed - trigger update
+    synchronizeWithServer(nodeHash);
+}
+
+// Validate entire subtree
+std::string treeHash = node->getTreeHash();
+if (treeHash != expectedTreeHash) {
+    // Subtree structure or data has changed
+    performFullValidation();
+}
+```
+
+### Factory Pattern Usage
+```cpp
+// JSON configuration
+std::unique_ptr<IDataTree> jsonTree = DataTreeFactory::create("json", "config/vehicles.json");
+
+// Future: Database configuration
+std::unique_ptr<IDataTree> dbTree = DataTreeFactory::create("database", "postgresql://config_db");
+
+// Future: Network configuration
+std::unique_ptr<IDataTree> netTree = DataTreeFactory::create("network", "https://api.example.com/config");
+```
+
+## UI Interface System (COMPLETED)
+
+### IUI Architecture
+- **Data-Agnostic Design**: Generic interface supporting all content types
+- **Type-Safe Enums**: DataType::ECONOMY, RequestType::GET_PRICES for performance
+- **Hierarchical Windowing**: Parent → Dock → Split → Tab → Window structure
+- **Hybrid Sizing System**: Percentage targets with absolute pixel constraints
+
+### ImGuiUI Implementation
+- **Complete Rendering Pipeline**: All DataType content renderers implemented
+- **Interactive Callbacks**: Request/response system with onRequest() + custom events
+- **Professional Layout**: Economic topbar + companies panel + strategic map + console
+- **State Management**: Window persistence, docking configuration, layout serialization
+
+## Module System Specifications
+
+### BREAKING CHANGES in IModule Interface
+```cpp
+// OLD Interface (DEPRECATED)
+class IModule {
+    virtual void initialize(const json& config, IIO* io, ITaskScheduler* scheduler) = 0;
+    virtual bool isHealthy() = 0;  // Simple boolean
+};
+
+// NEW Interface (CURRENT)
+class IModule {
+    virtual void setConfiguration(const IDataNode& configNode, IIO* io, ITaskScheduler* scheduler) = 0;
+    virtual const IDataNode& getConfiguration() = 0;
+    virtual json getHealthStatus() = 0;  // Detailed JSON report
+    // initialize() method REMOVED
+};
+```
+
+### Configuration Immutability Pattern
+```cpp
+// Modules receive const references - cannot modify configuration
+const IDataNode& config = coordinationModule->getConfigurationTree()->getNode("modules/production");
+
+// All getter methods are const to enforce read-only access
+int frequency = config.getInt("frequency", 60);  // const method
+std::string mode = config.getString("mode", "auto");  // const method
+
+// Modifications only possible through CoordinationModule
+coordinationModule->syncConfiguration();  // Reloads entire tree
+```
+
+### Module Health Monitoring
+```cpp
+// Detailed health status example
+json healthStatus = {
+    "status": "healthy|degraded|critical|offline",
+    "last_process_time_ms": 1.2,
+    "memory_usage_mb": 45,
+    "error_count": 0,
+    "warnings": ["High memory usage detected"],
+    "details": "All subsystems operational",
+    "uptime_seconds": 3600,
+    "processed_messages": 15420
+};
+```
+
+### Module Frequencies & Isolation
+- **ProductionModule**: 60Hz (frame-perfect factory operations)
+- **TankModule**: 0.1-60Hz (Targeting 60Hz → Movement 30Hz → Tactical 1Hz → Analytics 0.1Hz)
+- **EconomyModule**: 0.01-0.1Hz (economic cycles)
+- **War Isolation**: ZERO interaction ProductionModule ↔ WarModule
+- **Supply Chain**: Factory → LogisticModule → War (unidirectional flow)
+
+### Performance Targets
+- **V1 Client**: 30+ fps
+- **V2 Client**: 60+ fps
+- **V1 Server**: 10+ players
+- **V2 Server**: 100+ players
+
+## Development Constraints
+
+### Code Restrictions
+- **AUTO KEYWORD PROHIBITED**: Explicit types required throughout codebase
+- **Interface Immutability**: Core interfaces NEVER modified once finalized
+- **Module Isolation**: No `#include "../"` or parent directory references
+- **PUB/SUB Communication**: Module communication via IIO only
+
+### Build System
+- **Autonomous Builds**: Each module builds independently
+- **Hot-Reload**: 0.4ms average reload time achieved
+- **Cross-Platform**: Linux development → Windows .exe automated
+- **Debug Tools**: AddressSanitizer + UndefinedBehaviorSanitizer by default
+
+This document serves as the authoritative reference for all technical specifications in the Warfactory project.
\ No newline at end of file
diff --git a/docs/04-reference/updates-long-terme.md b/docs/04-reference/updates-long-terme.md
index c077441..1a4072a 100644
--- a/docs/04-reference/updates-long-terme.md
+++ b/docs/04-reference/updates-long-terme.md
@@ -134,6 +134,38 @@ class PsychologicalAntiCheat {
 - **Continuité améliorée** : Algorithmes liaison inter-chunks
 - **Biomes complexes** : Transitions naturelles entre terrains
 
+### Load Balancing et Distribution Avancée
+**Future évolution du CoordinationModule** pour optimisation performance automatique :
+
+#### Distribution Intelligente des Modules
+- **CPU Load Monitoring** : Surveillance utilisation processeur par module
+- **Network Latency Aware** : Placement modules selon latence réseau
+- **Memory Usage Optimization** : Répartition selon consommation mémoire
+- **Auto-scaling** : Lancement instances multiples modules haute charge
+
+#### Migration Dynamique
+```cpp
+class LoadBalancer {
+    void redistributeModules() {
+        // Analyse performance metrics
+        if (economyModule.getCPUUsage() > 80%) {
+            migrateToLowerLoadServer(economyModule);
+        }
+
+        // Optimisation latence
+        if (networkLatency(tankModule, productionModule) > 50ms) {
+            colocateModules(tankModule, productionModule);
+        }
+    }
+};
+```
+
+#### Stratégies de Placement
+- **Colocation Intelligente** : Modules communicants sur même serveur
+- **Geographic Distribution** : Placement modules selon localisation joueurs
+- **Resource Affinity** : Modules CPU-intensifs vs I/O-intensifs
+- **Hot-Standby** : Réplication modules critiques pour haute disponibilité
+
 ### Autres fonctionnalités à explorer
 *À compléter selon l'évolution du projet*
 
diff --git a/src/core/include/warfactory/ICoordinationModule.h b/src/core/include/warfactory/ICoordinationModule.h
new file mode 100644
index 0000000..0967fa6
--- /dev/null
+++ b/src/core/include/warfactory/ICoordinationModule.h
@@ -0,0 +1,161 @@
+#pragma once
+
+#include <string>
+#include <memory>
+#include <vector>
+#include <functional>
+#include "IModule.h"
+#include "IDataTree.h"
+
+// Forward declarations
+namespace warfactory {
+    class IEngine;
+    class IModuleSystem;
+}
+
+namespace warfactory {
+
+/**
+ * @brief Global system orchestrator - First launched, last shutdown
+ *
+ * The CoordinationModule is the main system orchestrator that manages the entire
+ * game system lifecycle, module deployment topology, and configuration synchronization.
+ *
+ * ARCHITECTURE FLOW:
+ * 1. MainServer launches CoordinationModule (first module)
+ * 2. CoordinationModule loads gameconfig.json via IDataTree
+ * 3. Parses deployment section to determine module topology
+ * 4. Deploys modules to local IEngine or remote servers
+ * 5. Synchronizes configuration across all deployed modules
+ * 6. Coordinates shutdown (last module to close)
+ *
+ * DESIGN DECISIONS:
+ * - No state persistence: behavior driven entirely by gameconfig.json
+ * - No network protocol: all communication via IIO abstraction
+ * - No security for now: local/trusted environment assumed
+ * - Module deployment via IModuleSystem delegation
+ * - Configuration immutability via const IDataNode references
+ */
+class ICoordinationModule : public IModule {
+public:
+    virtual ~ICoordinationModule() = default;
+
+    // ========================================
+    // GAME LIFECYCLE MANAGEMENT
+    // ========================================
+
+    /**
+     * @brief Start new game session with configuration
+     * @param gameConfigPath Path to gameconfig.json file
+     *
+     * Complete startup sequence:
+     * 1. Load and parse gameconfig.json via IDataTree
+     * 2. Initialize local IEngine and IModuleSystem
+     * 3. Parse deployment topology from config
+     * 4. Deploy local modules (target: "local")
+     * 5. Launch remote servers and deploy remote modules
+     * 6. Synchronize all configurations
+     * 7. Return when system is ready
+     */
+    virtual void startNewGame(const std::string& gameConfigPath) = 0;
+
+    /**
+     * @brief Load existing game from save file
+     * @param savePath Path to save file
+     */
+    virtual void loadGame(const std::string& savePath) = 0;
+
+    /**
+     * @brief Shutdown entire game system gracefully
+     *
+     * Coordinates graceful shutdown:
+     * 1. Signal all modules to save state
+     * 2. Undeploy remote modules first
+     * 3. Undeploy local modules
+     * 4. Shutdown remote servers
+     * 5. Shutdown local IEngine
+     * 6. CoordinationModule shuts down last
+     */
+    virtual void shutdownGame() = 0;
+
+    // ========================================
+    // MODULE DEPLOYMENT TOPOLOGY
+    // ========================================
+
+    /**
+     * @brief Deploy module according to gameconfig.json specification
+     * @param moduleInstanceId Module instance ID as defined in config
+     *
+     * Deployment process:
+     * 1. Read module config from gameconfig.json deployment section
+     * 2. Determine target: "local" vs "server:IP" vs "cluster:name"
+     * 3. Get module-specific configuration from modules section
+     * 4. For local: delegate to local IEngine->IModuleSystem
+     * 5. For remote: send deployment command to remote server
+     * 6. Pass const IDataNode& configuration to module
+     */
+    virtual void deployModule(const std::string& moduleInstanceId) = 0;
+
+    /**
+     * @brief Stop and undeploy module instance
+     * @param moduleInstanceId Module instance ID to undeploy
+     */
+    virtual void undeployModule(const std::string& moduleInstanceId) = 0;
+
+    /**
+     * @brief Get list of currently deployed module instances
+     * @return Vector of module instance IDs currently running
+     */
+    virtual std::vector<std::string> getDeployedModules() = 0;
+
+    // ========================================
+    // CONFIGURATION SYNCHRONIZATION
+    // ========================================
+
+    /**
+     * @brief Synchronize configuration changes to all deployed modules
+     *
+     * Process:
+     * 1. Reload gameconfig.json via IDataTree hot-reload
+     * 2. For each deployed module, get updated configuration
+     * 3. Call module->setConfiguration() with new const IDataNode&
+     * 4. Handle any modules that fail to reconfigure
+     */
+    virtual void syncConfiguration() = 0;
+
+    /**
+     * @brief Set configuration tree for the coordination system
+     * @param configTree Configuration data tree loaded from gameconfig.json
+     */
+    virtual void setConfigurationTree(std::unique_ptr<IDataTree> configTree) = 0;
+
+    /**
+     * @brief Get current configuration tree
+     * @return Configuration tree pointer for accessing gameconfig.json data
+     */
+    virtual IDataTree* getConfigurationTree() = 0;
+
+    // ========================================
+    // SYSTEM HEALTH AND MANAGEMENT
+    // ========================================
+
+    /**
+     * @brief Check if all deployed modules are healthy and responsive
+     * @return true if system is healthy, false if issues detected
+     *
+     * Aggregates health status from all deployed modules:
+     * - Calls getHealthStatus() on each module
+     * - Checks network connectivity to remote servers
+     * - Validates configuration consistency
+     * - Could trigger auto-save in future versions
+     */
+    virtual bool isSystemHealthy() = 0;
+
+    /**
+     * @brief Get detailed system health report
+     * @return JSON health report aggregating all module health status
+     */
+    virtual json getSystemHealthReport() = 0;
+};
+
+} // namespace warfactory
\ No newline at end of file
diff --git a/src/core/include/warfactory/IDataNode.h b/src/core/include/warfactory/IDataNode.h
index bd649ec..1f1df78 100644
--- a/src/core/include/warfactory/IDataNode.h
+++ b/src/core/include/warfactory/IDataNode.h
@@ -127,13 +127,13 @@ public:
      * @brief Get this node's data blob
      * @return JSON data or empty JSON if no data
      */
-    virtual json getData() = 0;
+    virtual json getData() const = 0;
 
     /**
      * @brief Check if this node has data
      * @return true if data exists
      */
-    virtual bool hasData() = 0;
+    virtual bool hasData() const = 0;
 
     /**
      * @brief Set this node's data
@@ -151,7 +151,7 @@ public:
      * @param defaultValue Default if property not found or wrong type
      * @return Property value or default
      */
-    virtual std::string getString(const std::string& name, const std::string& defaultValue = "") = 0;
+    virtual std::string getString(const std::string& name, const std::string& defaultValue = "") const = 0;
 
     /**
      * @brief Get integer property from this node's data
@@ -159,7 +159,7 @@ public:
      * @param defaultValue Default if property not found or wrong type
      * @return Property value or default
      */
-    virtual int getInt(const std::string& name, int defaultValue = 0) = 0;
+    virtual int getInt(const std::string& name, int defaultValue = 0) const = 0;
 
     /**
      * @brief Get double property from this node's data
@@ -167,7 +167,7 @@ public:
      * @param defaultValue Default if property not found or wrong type
      * @return Property value or default
      */
-    virtual double getDouble(const std::string& name, double defaultValue = 0.0) = 0;
+    virtual double getDouble(const std::string& name, double defaultValue = 0.0) const = 0;
 
     /**
      * @brief Get boolean property from this node's data
@@ -175,14 +175,14 @@ public:
      * @param defaultValue Default if property not found or wrong type
      * @return Property value or default
      */
-    virtual bool getBool(const std::string& name, bool defaultValue = false) = 0;
+    virtual bool getBool(const std::string& name, bool defaultValue = false) const = 0;
 
     /**
      * @brief Check if property exists in this node's data
      * @param name Property name
      * @return true if property exists
      */
-    virtual bool hasProperty(const std::string& name) = 0;
+    virtual bool hasProperty(const std::string& name) const = 0;
 
     // ========================================
     // HASH SYSTEM FOR VALIDATION & SYNCHRO
@@ -215,19 +215,19 @@ public:
      * @brief Get full path from root to this node
      * @return Path string (e.g., "vehicles/tanks/heavy/model5")
      */
-    virtual std::string getPath() = 0;
+    virtual std::string getPath() const = 0;
 
     /**
      * @brief Get this node's name
      * @return Node name
      */
-    virtual std::string getName() = 0;
+    virtual std::string getName() const = 0;
 
     /**
      * @brief Get node type (extensible for templates/inheritance later)
      * @return Node type identifier
      */
-    virtual std::string getNodeType() = 0;
+    virtual std::string getNodeType() const = 0;
 };
 
 } // namespace warfactory
\ No newline at end of file
diff --git a/src/core/include/warfactory/IEngine.h b/src/core/include/warfactory/IEngine.h
new file mode 100644
index 0000000..9f1a236
--- /dev/null
+++ b/src/core/include/warfactory/IEngine.h
@@ -0,0 +1,125 @@
+#pragma once
+
+#include <string>
+#include <memory>
+#include <nlohmann/json.hpp>
+
+// Forward declarations to avoid circular dependencies
+namespace warfactory {
+    class IModuleSystem;
+}
+
+using json = nlohmann::json;
+
+namespace warfactory {
+
+enum class EngineType {
+    DEBUG = 0,
+    PRODUCTION = 1,
+    HIGH_PERFORMANCE = 2
+};
+
+/**
+ * @brief Engine orchestration interface - coordinates the entire system
+ *
+ * The engine is responsible for:
+ * - System initialization and lifecycle management
+ * - Main game loop coordination with delta time updates
+ * - Module system orchestration
+ * - IIO health monitoring and backpressure management
+ *
+ * IMPORTANT: Engine implementations must periodically check IIO health:
+ * - Monitor IOHealth.queueSize vs maxQueueSize (warn at 80% full)
+ * - Track IOHealth.dropping status (critical - consider module restart)
+ * - Log IOHealth.droppedMessageCount for debugging
+ * - Monitor IOHealth.averageProcessingRate for performance analysis
+ *
+ * Evolution path:
+ * - DebugEngine: Development/testing with step-by-step execution
+ * - HighPerfEngine: Production optimized with threading
+ * - DataOrientedEngine: Massive scale with SIMD and clustering
+ */
+class IEngine {
+public:
+    virtual ~IEngine() = default;
+
+    /**
+     * @brief Initialize engine systems
+     *
+     * Sets up the engine with basic configuration.
+     * Module system and other components are set separately.
+     */
+    virtual void initialize() = 0;
+
+    /**
+     * @brief Start main game loop
+     *
+     * Blocks until shutdown() called. Engine owns the main loop and handles:
+     * - Frame timing and delta time calculation
+     * - Module system coordination
+     * - Performance management and frame rate control
+     */
+    virtual void run() = 0;
+
+    /**
+     * @brief Process single frame/tick (for debugging)
+     * @param deltaTime Time elapsed since last update in seconds
+     *
+     * For step debugging and testing. Processes one iteration
+     * without entering the main loop.
+     */
+    virtual void step(float deltaTime) = 0;
+
+    /**
+     * @brief Shutdown engine and cleanup all resources
+     *
+     * Ensures proper cleanup of all systems in correct order.
+     * Should be safe to call multiple times. Stops run() loop.
+     */
+    virtual void shutdown() = 0;
+
+    /**
+     * @brief Load modules from configuration
+     * @param configPath Path to module configuration file
+     *
+     * Engine automatically:
+     * - Loads modules from .so/.dll files
+     * - Creates appropriate ModuleSystem for each module (performance strategy)
+     * - Configures execution frequency and coordination
+     *
+     * Config format:
+     * {
+     *   "modules": [
+     *     {"path": "tank.so", "strategy": "threaded", "frequency": "60hz"},
+     *     {"path": "economy.so", "strategy": "sequential", "frequency": "0.1hz"}
+     *   ]
+     * }
+     */
+    virtual void loadModules(const std::string& configPath) = 0;
+
+    /**
+     * @brief Register main coordinator socket
+     * @param coordinatorSocket Socket for system coordination communication
+     *
+     * Engine uses this socket for high-level system coordination,
+     * health monitoring, and administrative commands.
+     */
+    virtual void registerMainSocket(std::unique_ptr<IIO> coordinatorSocket) = 0;
+
+    /**
+     * @brief Register new client/player socket
+     * @param clientSocket Socket for player communication
+     *
+     * Engine manages player connections as a priority channel.
+     * Players are the most important external connections.
+     */
+    virtual void registerNewClientSocket(std::unique_ptr<IIO> clientSocket) = 0;
+
+    /**
+     * @brief Get engine type identifier
+     * @return Engine type enum value for identification
+     */
+    virtual EngineType getType() const = 0;
+};
+
+} // namespace warfactory
\ No newline at end of file
diff --git a/src/core/include/warfactory/IIO.h b/src/core/include/warfactory/IIO.h
new file mode 100644
index 0000000..0f3edae
--- /dev/null
+++ b/src/core/include/warfactory/IIO.h
@@ -0,0 +1,102 @@
+#pragma once
+
+#include <string>
+#include <vector>
+#include <functional>
+#include <nlohmann/json.hpp>
+
+using json = nlohmann::json;
+
+namespace warfactory {
+
+enum class IOType {
+    INTRA = 0,      // Same process
+    LOCAL = 1,      // Same machine
+    NETWORK = 2     // TCP/WebSocket
+};
+
+struct SubscriptionConfig {
+    bool replaceable = false;        // Replace vs accumulate for low-freq
+    int batchInterval = 30000;       // ms for low-freq batching
+    int maxBatchSize = 100;         // Max messages per batch
+    bool compress = false;           // Compress batched data
+};
+
+struct Message {
+    std::string topic;
+    json data;
+    uint64_t timestamp;
+};
+
+struct IOHealth {
+    int queueSize;
+    int maxQueueSize;
+    bool dropping = false;           // Started dropping messages?
+    float averageProcessingRate;     // Messages/second processed by module
+    int droppedMessageCount = 0;     // Total dropped since last check
+};
+
+/**
+ * @brief Pub/Sub communication interface with pull-based synchronous design
+ *
+ * Pull-based pub/sub system optimized for game modules. Modules have full control
+ * over when they process messages, avoiding threading issues.
+ *
+ * Features:
+ * - Topic patterns with wildcards (e.g., "player:*", "economy:*")
+ * - Low-frequency subscriptions for bandwidth optimization
+ * - Message consumption (pull removes message from queue)
+ * - Engine health monitoring for backpressure management
+ */
+class IIO {
+public:
+    virtual ~IIO() = default;
+
+    /**
+     * @brief Publish message to a topic
+     * @param topic Topic name (e.g., "player:123", "economy:prices")
+     * @param message JSON message data
+     */
+    virtual void publish(const std::string& topic, const json& message) = 0;
+
+    /**
+     * @brief Subscribe to topic pattern (high-frequency)
+     * @param topicPattern Topic pattern with wildcards (e.g., "player:*")
+     * @param config Optional subscription configuration
+     */
+    virtual void subscribe(const std::string& topicPattern, const SubscriptionConfig& config = {}) = 0;
+
+    /**
+     * @brief Subscribe to topic pattern (low-frequency batched)
+     * @param topicPattern Topic pattern with wildcards
+     * @param config Subscription configuration (batchInterval, etc.)
+     */
+    virtual void subscribeLowFreq(const std::string& topicPattern, const SubscriptionConfig& config = {}) = 0;
+
+    /**
+     * @brief Get count of pending messages
+     * @return Number of messages waiting to be pulled
+     */
+    virtual int hasMessages() const = 0;
+
+    /**
+     * @brief Pull and consume one message
+     * @return Message from queue (oldest first). Message is removed from queue.
+     * @throws std::runtime_error if no messages available
+     */
+    virtual Message pullMessage() = 0;
+
+    /**
+     * @brief Get IO health status for Engine monitoring
+     * @return Health metrics including queue size, drop status, processing rate
+     */
+    virtual IOHealth getHealth() const = 0;
+
+    /**
+     * @brief Get IO type identifier
+     * @return IO type enum value for identification
+     */
+    virtual IOType getType() const = 0;
+};
+
+} // namespace warfactory
\ No newline at end of file
diff --git a/src/core/include/warfactory/IModule.h b/src/core/include/warfactory/IModule.h
new file mode 100644
index 0000000..e5f600c
--- /dev/null
+++ b/src/core/include/warfactory/IModule.h
@@ -0,0 +1,113 @@
+#pragma once
+
+#include <string>
+#include <nlohmann/json.hpp>
+#include "IDataNode.h"
+#include "ITaskScheduler.h"
+
+// Forward declarations
+namespace warfactory {
+    class IIO;
+}
+
+using json = nlohmann::json;
+
+namespace warfactory {
+
+
+
+/**
+ * @brief Pure business logic interface - optimized for Claude Code development
+ *
+ * This interface defines the contract for all game modules. Each module contains
+ * 200-300 lines of pure game logic with zero infrastructure code.
+ *
+ * Key design principles:
+ * - PURE FUNCTION: process() method has no side effects beyond return value
+ * - CONFIG VIA DATATREE: Configuration via immutable IDataNode references
+ * - JSON ONLY: All communication via JSON input/output
+ * - NO INFRASTRUCTURE: No threading, networking, or framework dependencies
+ * - HOT-RELOAD READY: State serialization for seamless module replacement
+ * - CLAUDE OPTIMIZED: Micro-context size for AI development efficiency
+ *
+ * BREAKING CHANGES:
+ * - Removed initialize() method - use setConfiguration() instead
+ * - Configuration via const IDataNode& for immutability
+ * - Health check returns detailed JSON status
+ *
+ * Module constraint: Maximum 300 lines per module (Exception: ProductionModule 500-800 lines)
+ */
+class IModule {
+public:
+    virtual ~IModule() = default;
+
+    /**
+     * @brief Process game logic
+     * @param input JSON input from other modules or the module system
+     *
+     * This is the core method where all module logic is implemented.
+     * Modules communicate via IIO pub/sub and can delegate tasks via ITaskScheduler.
+     * Must handle state properly through getState/setState for hot-reload.
+     */
+    virtual void process(const json& input) = 0;
+
+    /**
+     * @brief Set module configuration (replaces initialize)
+     * @param configNode Configuration node (immutable reference)
+     * @param io Pub/sub communication interface for messaging
+     * @param scheduler Task scheduling interface for delegating work
+     *
+     * Called when the module is loaded or configuration changes.
+     * Should setup internal state, validate configuration, and store service references.
+     */
+    virtual void setConfiguration(const IDataNode& configNode, IIO* io, ITaskScheduler* scheduler) = 0;
+
+    /**
+     * @brief Get current module configuration
+     * @return Configuration node reference
+     */
+    virtual const IDataNode& getConfiguration() = 0;
+
+    /**
+     * @brief Get detailed health status of the module
+     * @return JSON health report with status, metrics, and diagnostics
+     */
+    virtual json getHealthStatus() = 0;
+
+    /**
+     * @brief Cleanup and shutdown the module
+     *
+     * Called when the module is being unloaded. Should clean up any
+     * resources and prepare for safe destruction.
+     */
+    virtual void shutdown() = 0;
+
+    /**
+     * @brief Get current module state for hot-reload support
+     * @return JSON representation of all module state
+     *
+     * Critical for hot-reload functionality. Must serialize all internal
+     * state that needs to be preserved when the module is replaced.
+     * The returned JSON should be sufficient to restore the module to
+     * its current state via setState().
+     */
+    virtual json getState() = 0;
+
+    /**
+     * @brief Restore module state after hot-reload
+     * @param state JSON state previously returned by getState()
+     *
+     * Called after module replacement to restore the previous state.
+     * Must be able to reconstruct all internal state from the JSON
+     * to ensure seamless hot-reload without game disruption.
+     */
+    virtual void setState(const json& state) = 0;
+
+    /**
+     * @brief Get module type identifier
+     * @return Module type as string (e.g., "tank", "economy", "production")
+     */
+    virtual std::string getType() const = 0;
+};
+
+} // namespace warfactory
\ No newline at end of file
diff --git a/src/core/include/warfactory/IModuleSystem.h b/src/core/include/warfactory/IModuleSystem.h
new file mode 100644
index 0000000..e618912
--- /dev/null
+++ b/src/core/include/warfactory/IModuleSystem.h
@@ -0,0 +1,95 @@
+#pragma once
+
+#include <string>
+#include <memory>
+#include <nlohmann/json.hpp>
+#include "ITaskScheduler.h"
+
+// Forward declarations to avoid circular dependencies
+namespace warfactory {
+    class IModule;
+    class IIO;
+}
+
+using json = nlohmann::json;
+
+namespace warfactory {
+
+enum class ModuleSystemType {
+    SEQUENTIAL = 0,
+    THREADED = 1,
+    THREAD_POOL = 2,
+    CLUSTER = 3
+};
+
+
+/**
+ * @brief Module execution strategy interface - swappable performance architecture
+ *
+ * The module system manages module lifecycle and execution strategy.
+ * Different implementations provide different performance characteristics:
+ *
+ * - SequentialModuleSystem: Debug/test mode, processes modules one at a time
+ * - ThreadedModuleSystem: Each module in its own thread
+ * - MultithreadedModuleSystem: Module tasks distributed across thread pool
+ * - ClusterModuleSystem: Modules distributed across multiple machines
+ *
+ * This enables progressive evolution from debug to production to MMO scale
+ * without changing any module business logic code.
+ *
+ * Inherits from ITaskScheduler to provide task delegation capabilities.
+ */
+class IModuleSystem : public ITaskScheduler {
+public:
+    virtual ~IModuleSystem() = default;
+
+    /**
+     * @brief Register a module with the system
+     * @param name Unique identifier for the module
+     * @param module Module implementation (unique ownership)
+     *
+     * The module system takes ownership of the module and manages its lifecycle.
+     * Modules can be registered at any time and will participate in the next
+     * processing cycle.
+     */
+    virtual void registerModule(const std::string& name, std::unique_ptr<IModule> module) = 0;
+
+    /**
+     * @brief Process all registered modules
+     * @param deltaTime Time elapsed since last processing cycle in seconds
+     *
+     * This is the core execution method that coordinates all modules according
+     * to the implemented strategy. Each module's process() method will be called
+     * with appropriate timing and coordination.
+     */
+    virtual void processModules(float deltaTime) = 0;
+
+    /**
+     * @brief Set the IO layer for inter-module communication
+     * @param ioLayer Communication transport implementation (unique ownership)
+     *
+     * The module system takes ownership of the IO layer and uses it to
+     * facilitate communication between modules.
+     */
+    virtual void setIOLayer(std::unique_ptr<IIO> ioLayer) = 0;
+
+    /**
+     * @brief Query a specific module directly
+     * @param name Name of the module to query
+     * @param input JSON input to send to the module
+     * @return JSON response from the module
+     *
+     * This provides direct access to module functionality for debugging,
+     * testing, or administrative purposes. The query bypasses normal
+     * execution flow and calls the module's process() method directly.
+     */
+    virtual json queryModule(const std::string& name, const json& input) = 0;
+
+    /**
+     * @brief Get module system type identifier
+     * @return Module system type enum value for identification
+     */
+    virtual ModuleSystemType getType() const = 0;
+};
+
+} // namespace warfactory
\ No newline at end of file
diff --git a/src/core/include/warfactory/ITaskScheduler.h b/src/core/include/warfactory/ITaskScheduler.h
new file mode 100644
index 0000000..d92aa7b
--- /dev/null
+++ b/src/core/include/warfactory/ITaskScheduler.h
@@ -0,0 +1,102 @@
+#pragma once
+
+#include <string>
+#include <nlohmann/json.hpp>
+
+using json = nlohmann::json;
+
+namespace warfactory {
+
+/**
+ * @brief Task scheduling interface for module delegation to execution system
+ *
+ * ITaskScheduler allows modules to delegate computationally expensive or
+ * time-consuming tasks to the underlying execution system without knowing
+ * the implementation details (sequential, threaded, thread pool, cluster).
+ *
+ * CORE PURPOSE:
+ * - Modules stay lightweight (200-300 lines) by delegating heavy work
+ * - Execution strategy determined by IModuleSystem implementation
+ * - Modules remain thread-agnostic and infrastructure-free
+ *
+ * USAGE PATTERNS:
+ * - ProductionModule: Delegate belt pathfinding calculations
+ * - TankModule: Delegate A* pathfinding for unit movement
+ * - EconomyModule: Delegate market analysis and price calculations
+ * - FactoryModule: Delegate assembly line optimization
+ *
+ * EXECUTION STRATEGIES:
+ * - SequentialModuleSystem: Tasks executed immediately in same thread
+ * - ThreadedModuleSystem: Tasks executed in dedicated module thread
+ * - MultithreadedModuleSystem: Tasks distributed across thread pool
+ * - ClusterModuleSystem: Tasks distributed across remote workers
+ *
+ * PERFORMANCE BENEFIT:
+ * - Modules process() methods stay fast (< 1ms for 60Hz modules)
+ * - Heavy computation moved to background without blocking game loop
+ * - Automatic scaling based on IModuleSystem implementation
+ */
+class ITaskScheduler {
+public:
+    virtual ~ITaskScheduler() = default;
+
+    /**
+     * @brief Schedule a task for execution
+     * @param taskType Type of task (e.g., "pathfinding", "market_analysis", "belt_optimization")
+     * @param taskData JSON data for the task
+     *
+     * Example usage:
+     * ```cpp
+     * // TankModule delegates pathfinding
+     * scheduler->scheduleTask("pathfinding", {
+     *     {"start", {x: 100, y: 200}},
+     *     {"target", {x: 500, y: 600}},
+     *     {"unit_id", "tank_001"}
+     * });
+     *
+     * // ProductionModule delegates belt calculation
+     * scheduler->scheduleTask("belt_optimization", {
+     *     {"factory_id", "main_base"},
+     *     {"item_type", "iron_plate"},
+     *     {"throughput_target", 240}
+     * });
+     * ```
+     */
+    virtual void scheduleTask(const std::string& taskType, const json& taskData) = 0;
+
+    /**
+     * @brief Check if completed tasks are available
+     * @return Number of completed tasks ready to be pulled
+     *
+     * Modules should check this before calling getCompletedTask()
+     * to avoid blocking or polling unnecessarily.
+     */
+    virtual int hasCompletedTasks() const = 0;
+
+    /**
+     * @brief Pull and consume one completed task
+     * @return Task result JSON. Task is removed from completed queue.
+     *
+     * Example results:
+     * ```cpp
+     * // Pathfinding result
+     * {
+     *     "task_type": "pathfinding",
+     *     "unit_id": "tank_001",
+     *     "path": [{"x": 100, "y": 200}, {"x": 150, "y": 250}, ...],
+     *     "cost": 42.5
+     * }
+     *
+     * // Belt optimization result
+     * {
+     *     "task_type": "belt_optimization",
+     *     "factory_id": "main_base",
+     *     "optimal_layout": [...],
+     *     "efficiency_gain": 0.15
+     * }
+     * ```
+     */
+    virtual json getCompletedTask() = 0;
+};
+
+} // namespace warfactory
\ No newline at end of file
diff --git a/src/server/README.md b/src/server/README.md
index 7865117..6ad527a 100644
--- a/src/server/README.md
+++ b/src/server/README.md
@@ -1,30 +1,30 @@
 # Game Orchestrator
 
-Serveur central orchestrant les 10 engines autonomes et gérant les clients.
+Serveur central orchestrant le système modulaire et gérant les clients.
 
 ## Architecture
-- **Engine Coordination**: Orchestration des 10 engines autonomes
+- **Module Coordination**: Orchestration des modules via CoordinationModule
 - **Client Management**: REST API pour smart clients HTML
-- **Redis Coordination**: Communication inter-engines via Redis
-- **Performance**: 60fps tick global, engines autonomes
+- **Module Distribution**: Déploiement modules local/distant selon configuration
+- **Performance**: 60fps tick global, modules autonomes
 
 ## Responsabilités
 - **API Gateway**: Interface REST pour clients HTML
-- **Engine Lifecycle**: Start/stop/restart engines selon besoins
+- **Module Lifecycle**: Start/stop/restart modules selon besoins
 - **Session Management**: Gestion sessions joueurs multiples
-- **Data Coordination**: Synchronisation état entre engines
+- **Configuration Sync**: Synchronisation gameconfig.json entre modules
 
-## Engine Communication
-- **Factory Engine**: Production data, factory state
-- **Logistic Engine**: Transport routes, convoys
-- **Economy Engine**: Market prices, supply/demand
-- **Designer Engine**: Vehicle designs, blueprints
-- **MacroEntity Engine**: Company state, diplomacy
-- **Map Engine**: Terrain data, chunks, FOW
-- **War Engine**: Combat results, unit positions
-- **Operation Engine**: Strategic orders, AI decisions
-- **Intelligence Engine**: Metrics, reconnaissance data
-- **Event Engine**: Global events, breakthroughs
+## Module Communication
+- **Production Modules**: Factory state, belt optimization
+- **Logistic Modules**: Transport routes, convoys
+- **Economy Modules**: Market prices, supply/demand
+- **Designer Modules**: Vehicle designs, blueprints
+- **Company Modules**: Company state, diplomacy
+- **Map Modules**: Terrain data, chunks, FOW
+- **War Modules**: Combat results, unit positions
+- **Operation Modules**: Strategic orders, AI decisions
+- **Intelligence Modules**: Metrics, reconnaissance data
+- **Event Modules**: Global events, breakthroughs
 
 ## API Endpoints
 - `/api/map/*` - Map data, chunks, navigation