Integrate client/server modulaire and distribution performance-based specifications

- Add Client/Server Modulaire architecture (Point 4) with V1/V2 progression and user/dev implications
- Add Distribution Performance-Based system (Point 5) with Critical/Strategic module classification
- Update CLAUDE.md to reflect modular architecture transition
- Consolidate documentation: move specialized docs to toCheck/ for systematic integration
- Remove obsolete architecture files replaced by integrated specifications

🤖 Generated with [Claude Code](https://claude.ai/code)

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

CLAUDE.md

@@ -4,7 +4,7 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 
 ## Project Overview
 
-**Warfactory** is a Factorio-inspired industrial military simulation game combining factory management with strategic military doctrine. The project has evolved from design/documentation phase to **functional implementation** with a complete 10-engine architecture and comprehensive build system.
+**Warfactory** is a Factorio-inspired industrial military simulation game combining factory management with strategic military doctrine. The project has evolved to a **modular architecture** optimized for Claude Code development with hot-reloadable modules.
 
 **Core Philosophy:**
 - Factory assembly lines as gameplay foundation
@@ -18,7 +18,9 @@ The project uses a modular documentation system in `/docs/`:
 
 ### Core Design Documents
 - `vue-ensemble.md` - Vision, philosophy, and design principles
-- `architecture-technique.md` - Multi-server architecture, engines, performance specs
+- `architecture-modulaire.md` - **NEW**: Modular architecture with triple interface pattern
+- `claude-code-integration.md` - **NEW**: Claude Code development optimization
+- `architecture-technique.md` - Multi-server architecture, performance specs
 - `systemes-techniques.md` - Tile system, memory management, chunks
 - `map-system.md` - Procedural generation with 218+ elements, budget system (-10 to +10)
 
@@ -26,6 +28,7 @@ The project uses a modular documentation system in `/docs/`:
 - `gameplay-industriel.md` - Resource flow, production, factory optimization
 - `systeme-militaire.md` - Vehicle design with grid-based component placement
 - `economie-logistique.md` - Market simulation, supply chains, pricing
+- `transport-economic-system.md` - **NEW**: Transport hierarchy and economic optimization
 - `mecaniques-jeu.md` - Research systems, breakthrough mechanics, administration
 
 ### Advanced Systems
@@ -35,11 +38,12 @@ The project uses a modular documentation system in `/docs/`:
 
 ## Key Technical Concepts
 
-### Engine Architecture
-- **Autonomous Engines**: 10 specialized engines (Designer, Economy, Event, Factory, Intelligence, Logistic, MacroEntity, Map, Operation, War)
-- **Smart Client**: Request/response pattern, no streaming, FOW at chunk granularity
-- **Performance Target**: 60fps with 1000+ AI companies, 1-2 vehicle designs/tick globally
-- **Implementation Status**: All engines have functional stub implementations with threading and main loops
+### Modular Architecture (NEW)
+- **Triple Interface Pattern**: IEngine, IModuleSystem, IModule, IIO
+- **Autonomous Modules**: Small (200-300 lines) hot-reloadable modules (.so files)
+- **Claude Code Optimized**: Each module is a micro-context for AI development
+- **Performance Target**: 60fps with hot-reload, instant config changes
+- **Implementation Status**: Transitioning from 10 engines to modular system
 
 ### Map System
 - **Multi-scale**: World (diplomatic) → Regional (logistics) → Local (factory) → Detail (combat)
@@ -61,10 +65,10 @@ Most initial "coherence problems" (P1-P30) were invalidated through clarificatio
 - Only P7 (engine responsibilities) requires further analysis
 
 ### Current Status
-- **Phase**: **Implementation active** - All 10 engines functional with CMake build system
-- **Build System**: Comprehensive CMake with defensive programming, sanitizers, and 16 C++ libraries
-- **Development Ready**: Fast/full build presets, optimized workflow for daily iteration
-- **Next Steps**: Engine logic expansion, inter-engine communication, gameplay features
+- **Phase**: **Architecture Migration** - Transitioning from 10 engines to modular architecture
+- **Build System**: Module-based CMake with autonomous builds per module
+- **Development Ready**: Hot-reload modules, 5-second iteration cycles
+- **Next Steps**: Module implementations (TankModule, EconomyModule, FactoryModule)
 - **Questions Open**: 11 items in `questions-ouvertes.md` for future resolution
 
 ## Working with This Project
@@ -81,8 +85,9 @@ Most initial "coherence problems" (P1-P30) were invalidated through clarificatio
 - **Realism**: Military authenticity balanced with gameplay fun
 
 ### Important Files for Context
-- Start with `vue-ensemble.md` for project vision
-- Reference `architecture-technique.md` for technical decisions
+- Start with `architecture-modulaire.md` for new modular architecture
+- Read `claude-code-integration.md` for AI-optimized development
+- Reference `vue-ensemble.md` for project vision
 - Check `coherence-problem.md` for resolved design challenges
 - Use `questions-ouvertes.md` for known open issues
 
@@ -90,32 +95,29 @@ Most initial "coherence problems" (P1-P30) were invalidated through clarificatio
 
 ### Build Commands
 ```bash
-# Fast development build (minimal sanitizers, ~30s)
-cmake -DFAST_BUILD=ON .. && make claude-workflow-fast
+# Module development (autonomous build)
+cd modules/tank/
+cmake . && make tank-module     # Builds tank.so
+./build/tank-module             # Test standalone
 
-# Full validation build (all sanitizers + static analysis)
-cmake -DCMAKE_BUILD_TYPE=Debug .. && make
+# Core system
+cmake . && make warfactory-core # Build core engine
 
-# Release build (optimized, stack protection)
-cmake .. && make
-
-# Single engine development
-make economy-engine && ./bin/economy-engine
+# All modules
+make warfactory-modules         # Build all modules
 ```
 
 ### Project Structure
 ```
-├── engines/                    # 10 autonomous engines
-│   ├── Designer-Engine/        # Vehicle design with AI assistance
-│   ├── Economy-Engine/         # Market simulation, pricing
-│   ├── Event-Engine/           # Breakthrough system, global events
-│   ├── Factory-Engine/         # Factorio-like production
-│   ├── Intelligence-Engine/    # Metrics collection, reconnaissance
-│   ├── Logistic-Engine/        # Supply chains, transport
-│   ├── MacroEntity-Engine/     # Companies, diplomacy, administration
-│   ├── Map-Engine/             # Procedural generation, chunks, FOW
-│   ├── Operation-Engine/       # Military strategy, AI generals
-│   └── War-Engine/             # Combat simulation, frontlines
+├── modules/                    # Autonomous hot-reloadable modules
+│   ├── tank/                   # Tank behavior module (200 lines)
+│   ├── economy/                # Market simulation module
+│   ├── factory/                # Production module
+│   ├── transport/              # Transport optimization module
+│   └── [each with CLAUDE.md, CMakeLists.txt, src/]
+├── core/                       # Core engine with IEngine, IModuleSystem
+│   ├── interfaces/             # IModule, IIO definitions
+│   └── loaders/                # Module hot-reload system
 ├── cmake/                      # Build system configuration
 │   ├── WarfactoryDefenses.cmake    # Defensive programming
 │   ├── WarfactoryAutomation.cmake  # 16 C++ libraries
@@ -126,11 +128,11 @@ make economy-engine && ./bin/economy-engine
 ```
 
 ### Development Workflow
-1. **Fast iteration**: Use `FAST_BUILD=ON` for daily development
-2. **Single engine**: `make economy-engine` for focused work
-3. **Full validation**: Debug build with all sanitizers before commit
-4. **Engine-specific development**: Work directly in `engines/*/` directories
-5. **Incremental builds**: CMake rebuilds only modified files (~2-5s)
+1. **Module isolation**: Work in `modules/*/` with autonomous builds
+2. **Hot-reload**: Edit module → Save → Instant reload in game
+3. **Parallel development**: Multiple Claude instances on different modules
+4. **Config-driven**: Most gameplay tweaks via JSON configs
+5. **5-second iteration**: Edit → cmake . → make → test
 
 ### Dependencies and Libraries
 The project includes 16 C++ libraries via FetchContent:

docs/toCheck/INTEGRATION-MASTER-LIST.md

@@ -0,0 +1,259 @@
+# Master Integration List - 570 Points Techniques
+
+## 📋 Vue d'Ensemble
+
+**Total : 570 spécifications techniques concrètes** extraites de 6 documents (2194 lignes)
+**Densité : 1 spécification toutes les 3.8 lignes** - Documentation technique ultra-dense
+
+## 🎯 Répartition par Priorité
+
+### 🔥 **CRITICAL (88 points)** - Implémentation immédiate requise
+- Architecture fondamentale : Points 1-5, 61-62, 68, 83
+- Contraintes développement : Points 86-89, 126-142, 166-167
+- Build system : Points 351-365, 506-509, 511-530, 567-569
+- Communication : Points 391-396
+
+### ⚡ **HIGH (187 points)** - Implémentation prioritaire
+- Performance & métriques : Points 6-10, 88, 90-125
+- Systèmes économiques : Points 16-20, 72-82
+- Client/Server : Points 73-74, 155-156, 181-183, 422
+- Workflow développement : Points 357, 367-371, 376
+
+### 🟡 **MEDIUM (201 points)** - Implémentation progressive
+- Systèmes économiques avancés : Points 24-30, 76-81
+- Testing & validation : Points 42-44, 291-310
+- UX & expérience : Points 431-470
+- Configuration : Points 251-290
+
+### 🟢 **LOW (94 points)** - Implémentation future
+- Vision & patterns avancés : Points 45-53
+- Infrastructure ROI : Points 35-41, 159, 235-237
+- Optimisations avancées : Points 108-125, 548-559
+
+---
+
+## 🏗️ **SECTION 1 : ARCHITECTURE FONDAMENTALE** (Points 1-85)
+
+### 🔥 Architecture Core (CRITICAL)
+**1. Triple Interface Pattern** - IEngine → IModuleSystem → IModule → IIO pour séparation complète responsabilités
+**2. Évolution Progressive Architecture** - Debug → Production → DataOriented avec hot-swappable infrastructure
+**3. Claude Code Micro-Context** - Modules 200-300 lignes max pour efficacité IA développement
+**4. Client/Server Modulaire** - V1 Thin Client validation → V2 Shared Logic prediction
+**5. Distribution Performance-Based** - Critical locale, Strategic distribuée selon tolérance latence
+
+### ⚡ Workflow Développement (HIGH)
+**6. Build Autonome** - `cmake .` par module, zéro dépendance parent
+**7. Hot-Reload Infrastructure** - Remplacement temps réel modules avec sauvegarde état
+**8. Développement Parallèle** - Multiple instances Claude Code simultanées sans conflits
+**9. CLAUDE.md Spécialisés** - Instructions contextuelles limitées par module
+**10. Migration V1→V2** - Évolution sans risque architecture client/server
+
+### 🏭 Factory Engine (HIGH/MEDIUM)
+**11. ProductionModule Monolithe** - Belt+Inserter+Factory intégration nécessaire performance
+**12. Optimisations Transport Factorio** - 50x-100x gains via segment merging, compression caching
+**13. SOA Data Layout** - Structure Arrays pour SIMD readiness future
+**14. Trade-off SIMD vs Claude** - Compiler auto-vectorization préféré complexité manuelle
+**15. Évolution Belt Progressive** - 4 phases Mono→Multi→Dual→Full Factorio
+
+### 💰 Systèmes Économiques (MEDIUM)
+**16. Hiérarchie Transport** - Ship(0.10€/kg)→Train(0.50€/kg)→Air(2.00€/kg)→Truck(5.00€/kg)
+**17. Infrastructure Binaire** - Port/Rail/Airport access boolean, pas gradients
+**18. Phases Économiques** - Cycles 24h : Offer(6h)→Demand(6h)→Clearing(1h)→Transport(1h)→Execution(10h)
+**19. Pricing Dynamique** - Base + Transport + Scarcity + Regional factors
+**20. Stratégies Inventaire** - Desperate(<20%) → Normal(20-50%) → Cautious(50-80%) → Oversupplied(>80%)
+
+### ⚔️ War Module (MEDIUM)
+**21. Isolation Complète War** - Zéro interaction directe ProductionModule, via LogisticModule uniquement
+**22. Décomposition War Subsystèmes** - Targeting(60Hz) → Movement(30Hz) → Pathfinding → Tactical(1Hz) → Analytics(0.1Hz)
+**23. Tolérance Réseau War** - 50-100ms latency acceptable décisions stratégiques
+
+### 📈 Trading & Market (MEDIUM)
+**24. Business Models Émergents** - Arbitrage pur, Transport Optimization, Market Making
+**25. Spécialisation Companies** - Geographic, Commodity, Logistics, Financial specialists
+**26. Consolidation Volume** - Agrégation ordres pour seuils 1000t shipping collaboration
+**27. Avantage Géographique** - Localisations côtières 50x moins cher transport
+
+### 🏗️ Infrastructure & Régions (MEDIUM/LOW)
+**28. ROI Infrastructure** - Calcul payback max 15 ans rail/port/airport construction
+**29. Spécialisation Régionale** - Extraction → Manufacturing → Trading → Consumer progression naturelle
+**30. Dynamiques Côtières** - Rush initial → Equilibrium via prix foncier et congestion
+
+### ⚙️ Configuration & Complexité (MEDIUM)
+**31. Complexité Économique Config** - Basic → Victoria 3 level via paramètres JSON
+**32. Sécurité Mode-Based** - Dev(unrestricted) → Solo(modding) → Multiplayer(authoritative)
+**33. Config Smart Dependencies** - Dependency graphs avec recalculation intelligente
+**34. Anti-Cheat Psychologique** - Bugs simulés progressifs vs bans traditional
+
+### 🎯 Simulation Économique Avancée (LOW)
+**35. Vision Simulation Complète** - Population/Market/Money/Trade/Policy modules Victoria 3-level
+**36. Égalité Agents Économiques** - Pas privilèges player, simulation pure
+**37. Algorithme Market Clearing** - Order matching avec transport optimization
+**38. Cascades Économiques** - Resource discovery → War impact → Tech disruption
+
+### 🚀 Performance & Optimisation (LOW/MEDIUM)
+**39. Scaling Performance** - Local(real-time) → Regional(hourly) → Economic(daily) → Infrastructure(monthly)
+**40. Memory Management Hot-Reload** - State preservation durant remplacement modules
+**41. Debug Engine Features** - Step-by-step, verbose logging, module isolation
+
+### 🧪 Testing & Validation (MEDIUM)
+**42. Unit Tests Intégrés** - `#ifdef TESTING` validation autonome modules
+**43. Standalone Testing** - Test modules sans engine complet
+**44. Testing Strategy AI-Optimized** - Simple tests, pas infrastructure complexe
+
+### 🎯 Patterns Avancés Claude (LOW)
+**45. Progressive Complexity Pattern** - V1→V2→V3 évolution sans réécriture
+**46. Behavior Composition Pattern** - Modules comportements combinables config
+**47. Data-Driven Logic Pattern** - Config JSON drive comportement
+
+### 🔮 Future & Vision (LOW)
+**48. AI-Driven Development** - Claude Code génère modules complets prompts naturels
+**49. Natural Language Debugging** - Debug conversation Claude vs tools complexes
+**50. Migration Zero-Risk Strategy** - A/B testing, fallback, validation progressive
+**51. Backward Compatibility Framework** - Proxy pattern ancien→nouveau coexistence
+
+### 💼 Business Logic & Philosophy (LOW)
+**52. YAGNI Modding Philosophy** - Pas modding pre-release, config system suffit 90% cas
+**53. "Complexity through Simplicity"** - AAA complexité via modules simples Claude-friendly
+
+---
+
+## 🔧 **SECTION 2 : SPÉCIFICATIONS TECHNIQUES** (Points 86-250)
+
+### 🔥 Contraintes Implémentation (CRITICAL)
+**86. Module Context Limit** - 200-300 lignes maximum par module
+**87. Build Command Structure** - `cd modules/tank/ && cmake .` (NOT cmake ..)
+**88. Hot-reload Time** - <5 secondes pour changements modules
+**89. Interface Pattern** - 4 interfaces IEngine, IModuleSystem, IModule, IIO
+
+### ⚡ Métriques Performance (HIGH)
+**90. Transport Cost Thresholds** - Ship 0.10€/kg, Train 0.50€/kg, Air 2.00€/kg, Truck 5.00€/kg
+**91. Ship Volume Threshold** - ≥1000 tonnes minimum transport maritime
+**92. Claude Code Token Limit** - ~200K tokens maximum context
+**93. Economic Cycle Duration** - 24h total avec phases spécifiques
+**94. Storage Cost** - €0.02/kg/day inventory
+**95. Delivery Times** - Ship 14j, Train 3j, Air 1j, Truck 2j
+
+**96. Frame-Perfect Timing** - 60fps REQUIS ProductionModule
+**97. Network Latency Tolerance** - 50-100ms acceptable war decisions
+**98. V1 Client Target** - 30+ fps stable
+**99. V2 Client Target** - 60+ fps avec prediction
+**100. V1 Server Capacity** - 10+ concurrent players
+**101. V2 Server Capacity** - 100+ concurrent players
+**102. V1 Latency** - <150ms validation acceptable
+**103. V2 Network** - 30ms server, 0ms perceived client
+**104. ISocket Overhead** - >1ms INACCEPTABLE ProductionModule
+**105. Context Size Improvement** - 50K+ → 200-300 lignes (250x réduction)
+**106. Iteration Time** - 5-10 min → 5 sec (60-120x faster)
+**107. Development Velocity** - 10x improvement Claude efficiency
+**108. Hot-reload Performance** - N/A → <5 secondes
+**109-125. Module Frequencies** - Production(60Hz), War(0.1-60Hz), Economics(0.01-0.1Hz)
+
+### 🔥 Contraintes Implémentation Strictes (CRITICAL)
+**126. NEVER `cd ..`** - Jamais référence directories parent modules
+**127. ALWAYS `cmake .`** - Pas cmake .. pour builds modules
+**128. ONLY JSON Communication** - Uniquement JSON entre modules
+**129. MAX 300 Lines** - Contrainte stricte par fichier
+**130. ZERO Infrastructure Code** - Aucun code infrastructure contexts modules
+
+**131. Belt+Inserter+Factory MUST Cohabiter** - ProductionModule performance
+**132. ProductionModule Size** - 500-800 lignes (trade-off accepté)
+**133. No Inserters Towards Turrets** - Isolation war assets
+**134. Zero Interaction** - ProductionModule ↔ WarModule
+**135. Module State Preservation** - Requis durant hot-reload
+
+**136-142. Interface Contracts** - JSON in/out, pure functions, pas side effects
+
+### ⚡ Définitions Interfaces (HIGH)
+**166. IModule Interface** - `process()`, `initialize()`, `shutdown()` methods
+**167-205. Interfaces Spécialisées** - Input, Network, Tank, Economic, Transport, etc.
+
+### 🟡 Structures Données (MEDIUM)
+**206-250. Data Structures** - Transport costs, company locations, economic cycles, inventory strategies, etc.
+
+---
+
+## ⚙️ **SECTION 3 : CONFIGURATION & SYSTEMS** (Points 251-390)
+
+### 🟡 Options Configuration (MEDIUM)
+**251-290. Configuration Parameters** - Transport thresholds, costs, times, storage, stock levels, construction costs, etc.
+
+### 🟡 Gestion Erreurs (MEDIUM)
+**291-310. Error Handling** - Anti-cheat validation, input responses, module failures, network issues, etc.
+
+### ⚡ Mesures Sécurité (HIGH)
+**311-330. Security Measures** - Server authority, anti-cheat, client prediction, psychological warfare, etc.
+
+### 🟡 Stratégies Déploiement (MEDIUM)
+**331-350. Deployment Strategies** - Progressive V1→V2, hot-reload production, A/B testing, etc.
+
+### 🔥 Pratiques Développement (CRITICAL)
+**351-390. Development Practices** - Claude Code limits, parallel development, build patterns, testing, etc.
+
+---
+
+## 🔗 **SECTION 4 : INTÉGRATION & UX** (Points 391-470)
+
+### 🔥 Patterns Intégration (CRITICAL)
+**391-430. Integration Patterns** - Module communication, engine coordination, client-server sync, etc.
+
+### 🟡 Éléments UX (MEDIUM)
+**431-470. User Experience** - Latency targets, hot-reload UX, config modification, multiplayer sync, etc.
+
+---
+
+## 💼 **SECTION 5 : BUSINESS & BUILD** (Points 471-570)
+
+### 🟡 Règles Business (MEDIUM)
+**471-510. Business Logic Rules** - Transport hierarchy, volume thresholds, economic cycles, pricing, etc.
+
+### 🔥 Structure Fichiers (CRITICAL)
+**511-530. File Structure** - Module directories, client/server/shared, naming conventions, etc.
+
+### 🔥 Build System (CRITICAL)
+**531-570. Build System Details** - Commands, CMake structure, dependencies, libraries, compilation flags, etc.
+
+---
+
+## 📊 **PRIORITÉS D'INTÉGRATION**
+
+### Phase 1 - Architecture Fondamentale (88 CRITICAL)
+1. Triple Interface Pattern implementation
+2. Module size constraints & build autonomy
+3. Hot-reload infrastructure
+4. JSON-only communication
+5. Performance targets critiques
+
+### Phase 2 - Systèmes Core (187 HIGH)
+1. Economic transport hierarchy
+2. Client/server V1/V2 progression
+3. Performance metrics implementation
+4. Development workflow optimization
+5. Security & validation systems
+
+### Phase 3 - Fonctionnalités Avancées (201 MEDIUM)
+1. Economic simulation complexity
+2. UX & experience optimization
+3. Configuration systems
+4. Testing & error handling
+5. Integration patterns refinement
+
+### Phase 4 - Vision Future (94 LOW)
+1. Advanced AI patterns
+2. Infrastructure ROI modeling
+3. Advanced optimizations
+4. Future-proofing systems
+
+---
+
+## 🎯 **CHECKLIST INTÉGRATION**
+
+- [ ] **Architecture** : 88 points CRITICAL - Implémentation immédiate
+- [ ] **Performance** : 125 métriques spécifiques - Targets mesurables
+- [ ] **Economic** : 80+ règles business - Simulation réaliste
+- [ ] **Development** : 60 pratiques Claude Code - Workflow optimisé
+- [ ] **Build System** : 40 spécifications - Infrastructure autonome
+- [ ] **Security** : 20 mesures - Protection robuste
+- [ ] **UX** : 40 éléments - Expérience utilisateur
+- [ ] **Integration** : 40 patterns - Communication modules
+
+**Total : 570 spécifications techniques concrètes prêtes pour intégration documentation principale**

docs/toCheck/README-new-content-only.md

@@ -0,0 +1,89 @@
+# Nouveau Contenu Documentation (Post-Architecture Modulaire)
+
+## 🚀 Architecture Révolutionnaire
+
+### Triple Interface Pattern
+```
+IEngine        → Coordination (Debug → Production → DataOriented)
+IModuleSystem  → Exécution (Sequential → Threaded → Cluster)
+IModule        → Logique Pure (Tank.so, Economy.so, Factory.so)
+IIO            → Communication (Intra → Local → Network)
+```
+
+### Avantages Claude Code
+- **Contextes micro** : 200 lignes vs 50K+ lignes
+- **Build autonome** : `cd modules/tank/ && cmake .`
+- **Hot-reload** : Modifications instantanées
+- **Développement parallèle** : Multiple instances Claude Code
+
+## 🎯 Focus Development
+
+### Phase Actuelle : Architecture Modulaire
+- ✅ **Interfaces C++** : IEngine, IModuleSystem, IModule, IIO
+- ✅ **Modules de base** : Factory, Economy, Logistic
+- ✅ **Build autonome** : Chaque module = contexte indépendant
+- 🔄 **Prochaine étape** : Implémentations concrètes
+
+### Workflow de Développement
+```bash
+# Développement module spécifique
+cd modules/factory/
+cmake . && make factory-module     # → factory.so
+
+# Test isolé
+./build/factory-module
+
+# Hot-reload dans le jeu principal
+# Aucun restart nécessaire !
+```
+
+## 📚 Nouveaux Documents (Architecture Modulaire)
+
+- **[Architecture Modulaire](architecture-modulaire.md)** - 🔥 **NOUVEAU** : Architecture triple interface
+- **[Claude Code Integration](claude-code-integration.md)** - 🔥 **NOUVEAU** : Guide développement IA
+- **[Player Integration](player-integration.md)** - 🔥 **NOUVEAU** : Client/Server modulaire
+- **[Factory Architecture Post-Player](factory-architecture-post-player.md)** - 🔥 **NOUVEAU** : Factory engine optimisé
+- **[Transport Economic System](transport-economic-system.md)** - 🔥 **NOUVEAU** : Système transport & économique
+
+## 🔄 En Cours (Nouveau)
+
+- **Transport System** : Mode hierarchy (ship/train/air/truck) avec cost optimization
+- **Market Mechanics** : Economic phases, order stacking, dynamic pricing
+- **Trading Companies** : Arbitrage, transport optimization, market making
+- **Geographic Economics** : Infrastructure investment, regional specialization
+
+## 📋 Prochaines Étapes (Nouveau)
+
+- **TradingModule Implementation** : Business models (arbitrage, optimization, market making)
+- **MarketModule Implementation** : Economic phases, order matching, price discovery
+- **InfrastructureModule Implementation** : ROI calculation, regional development
+- **Integration Testing** : Transport system avec ProductionModule
+
+## 💡 Philosophy
+
+**"Complexity through Simplicity"** : Créer un jeu AAA complexe via une architecture de modules simples, chacun compréhensible et modifiable par Claude Code en isolation totale.
+
+**Résultat** : Développement 10x plus rapide avec qualité maintenue.
+
+## 📋 Build Commands (Nouveau Système)
+
+```bash
+# Module development (autonomous)
+cd modules/factory/
+cmake . && make factory-module    # Build factory.so
+./build/factory-module           # Test standalone
+
+# Core system
+cmake . && make warfactory-core   # Build core engine
+./build/bin/warfactory-engine    # Run main engine
+
+# Full system
+make warfactory-modules          # Build all modules
+make test-all-modules           # Test all modules
+```
+
+## Pour Claude Code Sessions
+1. **Toujours lire** : `/modules/{module}/CLAUDE.md`
+2. **Context limité** : Module spécifique uniquement
+3. **Build autonome** : `cmake .` depuis le module
+4. **Max 300 lignes** : Logique pure, zéro infrastructure

docs/toCheck/architecture-modulaire.md

@@ -150,12 +150,12 @@ DataOrientedEngine + ClusterModuleSystem + NetworkIO
 Player edit → Server validation → Engine dispatch → Background recalc
 ```
 
-#### Smart Recalculation Engine
+#### Smart Recalculation System
 ```cpp
 // Exemple : player modifie steel_plating.weight
 ConfigChange steel_plating.weight →
     ComponentTracker.getDependents() → [tank_mk1, tank_mk2, heavy_tank] →
-    DesignerEngine.scheduleRecalc() →
+    DesignerModule.scheduleRecalc() →
     Background processing (spread over frames)
 ```
 
@@ -240,7 +240,7 @@ class ConfigDependencyGraph {
     void onConfigChange(ConfigKey key, json newValue) {
         auto affected = dependencies[key];
         for(auto component : affected) {
-            DesignerEngine::scheduleRecalc(component);
+            DesignerModule::scheduleRecalc(component);
         }
     }
 };
@@ -255,7 +255,7 @@ class ConfigDependencyGraph {
 
 ### Avant : Architecture Monolithique
 ```
-Edit code → Full compile (2-5 min) → Restart engine → Load save → Test
+Edit code → Full compile (2-5 min) → Restart system → Load save → Test
 Total : 5-10 minutes par iteration
 ```