diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md
new file mode 100644
index 0000000..54a081a
--- /dev/null
+++ b/ARCHITECTURE.md
@@ -0,0 +1,233 @@
+# Architecture Game-Agnostic
+
+**Date** : 2 décembre 2025
+**Version** : 0.1.0
+
+## Principe Fondamental
+
+Les modules **core** sont game-agnostic et réutilisables entre Mobile Command et WarFactory.
+La logique spécifique au jeu se fait via **pub/sub** dans GameModule.
+
+## Structure
+
+```
+┌──────────────────────────────────────┐
+│  GameModule (MC-specific)            │
+│  ┌────────────────────────────────┐  │
+│  │ Subscribe aux events core      │  │
+│  │ Applique logique MC            │  │
+│  │ (drones, train, expeditions)   │  │
+│  └────────────────────────────────┘  │
+└────────────┬─────────────────────────┘
+             │ pub/sub via grove::IIO
+             │
+┌────────────▼─────────────────────────┐
+│  Core Modules (Game-Agnostic)        │
+│  ┌────────────────────────────────┐  │
+│  │ ResourceModule                 │  │
+│  │ - Inventaire                   │  │
+│  │ - Craft                        │  │
+│  │ - Quality                      │  │
+│  │                                │  │
+│  │ Publie: resource:*             │  │
+│  │ PAS de logique MC/WF           │  │
+│  └────────────────────────────────┘  │
+│  ┌────────────────────────────────┐  │
+│  │ StorageModule                  │  │
+│  │ CombatModule                   │  │
+│  │ EventModule                    │  │
+│  └────────────────────────────────┘  │
+└──────────────────────────────────────┘
+```
+
+## Exemples
+
+### ResourceModule (Core - Game-Agnostic)
+
+**Ce qu'il FAIT** :
+```cpp
+class ResourceModule : public grove::IModule {
+    bool addResource(string id, int quantity);
+    bool removeResource(string id, int quantity);
+    bool canCraft(string recipeId);
+    void startCraft(string recipeId);
+
+    void process(float dt) {
+        updateCrafting(dt);
+        if (craftComplete) {
+            io->publish("resource:craft_complete", craftData);
+        }
+    }
+};
+```
+
+**Ce qu'il NE FAIT PAS** :
+- ❌ Savoir ce qu'est un "drone" ou un "tank"
+- ❌ Connaître les expéditions ou factories
+- ❌ Gérer le train ou les wagons
+- ❌ Appliquer fame bonus
+- ❌ Contenir logique MC ou WF
+
+### GameModule (MC-Specific)
+
+**Ce qu'il FAIT** :
+```cpp
+class GameModule : public grove::IModule {
+    void initialize() {
+        // Subscribe aux events core
+        io->subscribe("resource:craft_complete", [this](const IDataNode& data) {
+            string recipe = data.getString("recipe");
+
+            // LOGIQUE MC ICI
+            if (recipe == "drone_recon") {
+                // MC: Ajouter aux expéditions
+                m_availableDrones["recon"]++;
+                io->publish("expedition:drone_available", droneData);
+
+                // MC: Fame bonus si 2024+
+                if (m_timeline.year >= 2024) {
+                    io->publish("fame:gain", fameData);
+                }
+            }
+        });
+
+        io->subscribe("resource:inventory_low", [this](const IDataNode& data) {
+            // MC: Warning train storage
+            showWarning("Fuel bas ! Retour au train recommandé.");
+        });
+    }
+};
+```
+
+## Topics Pub/Sub
+
+### ResourceModule
+- `resource:craft_complete` - {recipe, result, quantity}
+- `resource:craft_started` - {recipe, duration}
+- `resource:inventory_changed` - {resource_id, delta, total}
+- `resource:inventory_low` - {resource_id, threshold}
+- `resource:storage_full` - {}
+
+### StorageModule
+- `storage:save_complete` - {filename, timestamp}
+- `storage:load_complete` - {filename, version}
+- `storage:save_failed` - {error}
+
+### CombatModule
+- `combat:started` - {location, combatants}
+- `combat:round_complete` - {casualties, damage}
+- `combat:ended` - {victory, loot, casualties}
+
+### EventModule
+- `event:triggered` - {event_id, conditions}
+- `event:choice_made` - {event_id, choice_id}
+- `event:outcome` - {resources, flags}
+
+## Configuration
+
+### Core Modules
+Config JSON pure, pas de hardcoded behavior.
+
+**resources.json (MC)** :
+```json
+{
+  "resources": {
+    "scrap_metal": {"maxStack": 100, "weight": 1.5},
+    "drone_parts": {"maxStack": 50, "weight": 0.5}
+  },
+  "recipes": {
+    "drone_recon": {
+      "inputs": {"drone_parts": 3, "electronics": 2},
+      "outputs": {"drone_recon": 1},
+      "time": 120
+    }
+  }
+}
+```
+
+**resources.json (WF - futur)** :
+```json
+{
+  "resources": {
+    "iron_ore": {"maxStack": 1000, "weight": 2.0},
+    "steel_plates": {"maxStack": 500, "weight": 5.0}
+  },
+  "recipes": {
+    "tank_t72": {
+      "inputs": {"steel_plates": 50, "engine": 1},
+      "outputs": {"tank_t72": 1},
+      "time": 600
+    }
+  }
+}
+```
+
+Même code ResourceModule, configs différentes → Comportements différents.
+
+## Checklist Module Core
+
+Avant de commiter un module core :
+
+- [ ] ❌ Aucune mention de "Mobile Command", "WarFactory", "train", "factory", "drone", "tank"
+- [ ] ✅ Interface pure (fonctions publiques génériques)
+- [ ] ✅ Tout comportement via config JSON
+- [ ] ✅ Communication via pub/sub uniquement
+- [ ] ✅ Topics documentés en commentaires
+- [ ] ✅ Exemple usage MC + WF en commentaires
+- [ ] ✅ Hot-reload state preservation
+- [ ] ✅ Tests basiques passent
+
+## Règles d'Or
+
+1. **Core = Generic** - Si tu penses "drone" ou "train", c'est game-specific
+2. **Config > Code** - Behavior via JSON, pas hardcodé
+3. **Pub/Sub Only** - Modules ne se référencent jamais directement
+4. **Think Both Games** - Chaque feature core doit avoir sens pour MC ET WF
+5. **Test Reusability** - Si tu ne peux pas imaginer WF l'utiliser, refactor
+
+## Bénéfices
+
+### Court Terme (Prototype MC)
+- Architecture propre, modules découplés
+- Hot-reload rapide (modules petits)
+- Tests unitaires faciles
+
+### Moyen Terme (MVP MC)
+- Code stable, bien testé
+- Pas de spaghetti code
+- Maintenance simplifiée
+
+### Long Terme (WF + MC)
+- **Réutilisation massive** : WF bénéficie du code MC
+- **Bugs fixés une fois** : Profit aux deux projets
+- **Features partagées** : Economy, storage, combat
+- **Extraction library** : grove-modules/ opensource possible
+
+## Future: grove-modules/ Library
+
+Quand modules stabilisés (Post-MVP MC) :
+
+```
+../grove-modules/           # Bibliothèque partagée
+├── core/
+│   ├── ResourceModule/
+│   ├── StorageModule/
+│   ├── CombatModule/
+│   └── EventModule/
+└── README.md
+
+../mobilecommand/
+└── external/
+    ├── GroveEngine/
+    └── grove-modules/      # Symlink
+
+../warfactoryracine/
+└── external/
+    └── grove-modules/      # Symlink
+```
+
+**Plan complet** : Voir `plans/SHARED_MODULES_PLAN.md`
+
+---
+
+**TL;DR** : Core modules = Generic library. Game logic = GameModule via pub/sub.
diff --git a/CLAUDE.md b/CLAUDE.md
index 59a861b..b5c51ef 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -10,19 +10,51 @@ Je suis l'assistant de développement pour le projet Mobile Command.
 ### Stack Technique
 - **Engine**: GroveEngine (C++17 hot-reload module system)
 - **Build**: CMake 3.20+ avec MinGW/GCC
-- **Architecture**: Main loop + modules hot-reloadable
+- **Architecture**: Modules game-agnostic + adapters game-specific
+
+### Architecture Game-Agnostic
+
+**PRINCIPE CLÉ** : Les systèmes core sont réutilisables entre Mobile Command et WarFactory.
+
+```
+┌──────────────────────────────────────┐
+│  GameModule (MC-specific)            │  ← Pilote et orchestration
+│  - State machine du jeu              │
+│  - Flow spécifique MC                │
+└────────────┬─────────────────────────┘
+             │ pub/sub via IIO
+┌────────────▼─────────────────────────┐
+│  Core Modules (Game-Agnostic)        │  ← Réutilisables MC/WF
+│  - ResourceModule                     │
+│  - StorageModule                      │
+│  - CombatModule                       │
+│  - EventModule                        │
+│  → Aucune logique MC/WF hardcodée    │
+└──────────────────────────────────────┘
+```
 
 ### Structure du Projet
 ```
 mobilecommand/
-├── external/GroveEngine/   # Lien symbolique vers ../groveengine
+├── external/GroveEngine/        # Lien symbolique vers ../groveengine
 ├── src/
-│   ├── main.cpp           # Boucle principale (10Hz)
-│   └── modules/           # Modules hot-reloadable (.dll)
-│       └── GameModule.*   # Module de jeu principal
+│   ├── main.cpp                 # Boucle principale
+│   └── modules/
+│       ├── core/                # Game-agnostic (réutilisables)
+│       │   ├── ResourceModule.*
+│       │   ├── StorageModule.*
+│       │   ├── CombatModule.*
+│       │   └── EventModule.*
+│       ├── mc_specific/         # Mobile Command only
+│       │   ├── TrainBuilderModule.*
+│       │   ├── ExpeditionModule.*
+│       │   └── DroneModule.*
+│       └── GameModule.*         # Orchestrateur MC-specific
 ├── config/
-│   └── game.json          # Configuration
-└── build/                 # Dossier de build
+│   ├── game.json                # Config MC
+│   ├── resources.json           # Ressources MC
+│   └── ...
+└── build/                       # Dossier de build
 ```
 
 ## Workflow de Développement
@@ -59,15 +91,40 @@ cd build && ./mobilecommand.exe
 - Chargés dynamiquement (.dll/.so)
 - Hot-reload < 1ms avec état préservé
 
-### Communication
-- `grove::IIO` pour pub/sub entre modules
-- Messages via `grove::IDataNode` (JSON)
-- Topics: `module:event` (ex: `game:tick`, `train:damaged`)
+### Communication Pub/Sub (IIO)
+**CRITIQUE pour architecture game-agnostic** : Les modules ne se connaissent pas directement.
+
+```cpp
+// Core module publie (game-agnostic)
+io->publish("resource:craft_complete", craftData);
+
+// GameModule MC subscribe (MC-specific)
+io->subscribe("resource:craft_complete", [this](const IDataNode& data) {
+    string recipe = data.getString("recipe");
+    if (recipe == "drone_recon") {
+        // Logique MC : ajouter drone aux expéditions
+        io->publish("expedition:drone_available", droneData);
+    }
+});
+
+// Future: GameModule WF subscribe (WF-specific)
+io->subscribe("resource:craft_complete", [this](const IDataNode& data) {
+    // Logique WF : ajouter à factory output
+    io->publish("factory:production_complete", productData);
+});
+```
+
+**Topics Convention** : `module:event`
+- `resource:craft_complete`, `resource:inventory_low`
+- `combat:started`, `combat:ended`
+- `event:triggered`, `event:choice_made`
+- `storage:save_complete`
 
 ### Configuration
 - Fichiers JSON dans `config/`
 - Chargés via `grove::JsonDataNode`
 - Hot-reload de config supporté
+- **Config spécifique par jeu** : `config/resources.json` différent pour MC/WF
 
 ## Roadmap
 
@@ -91,9 +148,38 @@ cd build && ./mobilecommand.exe
 
 ## Conventions de Code
 
-### Modules
+### Modules Core (Game-Agnostic)
+**RÈGLES STRICTES** :
+- ❌ JAMAIS de référence à "Mobile Command", "WarFactory", "train", "factory"
+- ❌ JAMAIS de hardcoded game logic
+- ✅ Interface pure avec pub/sub
+- ✅ Configuration JSON pour tout comportement spécifique
+- ✅ Commentaires expliquant l'usage MC ET WF
+
+**Exemple** :
+```cpp
+// ResourceModule.h - GAME-AGNOSTIC
+class ResourceModule : public grove::IModule {
+public:
+    // Interface pure
+    bool addResource(string id, int quantity);
+    bool canCraft(string recipeId);
+    void startCraft(string recipeId);
+
+    // Pub/sub pour logique game-specific
+    void process(float dt) override;
+
+private:
+    // Data pure - pas de logique game
+    map<string, int> m_inventory;
+    // PAS DE: TrainCargo, FactoryOutput, etc.
+};
+```
+
+### Modules MC-Specific
 - Nom: `XyzModule` (PascalCase)
-- Fichiers: `XyzModule.cpp` + `XyzModule.h` (optionnel)
+- Fichiers: `mc_specific/XyzModule.cpp` + `.h`
+- Peut référencer concepts MC (train, expedition, drones)
 - Exports: `createModule()` et `destroyModule()`
 
 ### Logging
@@ -115,19 +201,35 @@ int value = config->getInt("key", defaultValue);
 ### Primaire
 Créer un jeu de gestion/survie autour d'un train blindé mobile
 
-### Secondaire  
-Valider GroveEngine en conditions réelles de production
+### Secondaire
+1. Valider GroveEngine en conditions réelles de production
+2. **Créer une bibliothèque de modules réutilisables** pour WarFactory
+
+### Tertiaire
+Extraire modules core vers `grove-modules/` library partagée (Phase 2)
 
 ## Notes Importantes
 
-- Le projet est en phase prototype
-- Focus sur la validation des mécaniques de base
-- Hot-reload est essentiel au workflow
-- Garder les modules simples et focalisés
+- **Phase prototype** : Focus validation mécaniques
+- **Architecture game-agnostic dès le début** : Modules core réutilisables
+- **Hot-reload essentiel** : Development velocity
+- **Simplicité > Complexité** : Valider concepts avant d'optimiser
+- **Pub/sub strict** : Modules ne se couplent jamais directement
+
+## Checklist Modules Core
+
+Avant de commiter un module core, vérifier :
+- [ ] Aucune référence MC/WF dans le code
+- [ ] Interface pure (pas de logique hardcodée)
+- [ ] Configuration JSON pour comportements spécifiques
+- [ ] Topics pub/sub documentés
+- [ ] Exemples d'usage MC ET WF en commentaires
+- [ ] Tests basiques fonctionnent
 
 ## Ressources
 
+- **Plans détaillés**: `plans/PROTOTYPE_PLAN.md` et `plans/SHARED_MODULES_PLAN.md`
+- **Architecture modules**: `docs/MODULES_ARCHITECTURE.md`
 - **Concept complet**: `../couple-repo/Projects/CONCEPT/mobile_command_v2.md`
 - **GroveEngine docs**: `external/GroveEngine/README.md`
-- **Architecture GroveEngine**: `external/GroveEngine/docs/architecture/`
 
diff --git a/README.md b/README.md
index 46c07fa..becda40 100644
--- a/README.md
+++ b/README.md
@@ -4,6 +4,12 @@
 
 Genre de jeu de gestion/survie où vous commandez un train blindé mobile à travers l'Ukraine en guerre (2022-2025).
 
+---
+
+**🎮 Prototype Phase 1/4** | **🔧 GroveEngine C++17** | **♻️ Game-Agnostic Core** | **🔥 Hot-Reload < 1ms**
+
+---
+
 ## Concept Central
 
 **"La guerre change. Tu dois changer avec elle."**
@@ -25,22 +31,39 @@ Le jeu force une évolution : De commandant infantry-heavy (2022) à opérateur
 
 ## Architecture Projet
 
+### Principe Clé : Game-Agnostic Core
+
+Les modules core sont conçus pour être **réutilisables** entre Mobile Command et WarFactory.
+
 ```
 mobilecommand/
 ├── external/
-│   └── GroveEngine/          # GroveEngine (symlink vers ../groveengine)
+│   └── GroveEngine/          # GroveEngine (symlink)
 ├── src/
 │   ├── main.cpp              # Main application loop
 │   └── modules/
-│       └── GameModule.*      # Core game loop (hot-reloadable)
+│       ├── core/             # 🔄 Game-agnostic (réutilisables)
+│       │   ├── ResourceModule.*    # Inventaire, craft
+│       │   ├── StorageModule.*     # Save/load
+│       │   ├── CombatModule.*      # Combat resolver
+│       │   └── EventModule.*       # Event system
+│       ├── mc_specific/      # 📦 Mobile Command only
+│       │   ├── TrainBuilderModule.*
+│       │   ├── ExpeditionModule.*
+│       │   └── DroneModule.*
+│       └── GameModule.*      # Orchestrateur MC-specific
 ├── config/
-│   └── game.json             # Game configuration
-├── build/                    # Build directory
-│   ├── mobilecommand.exe     # Main executable
-│   └── modules/              # Hot-reloadable modules (.dll)
-└── CMakeLists.txt
+│   ├── game.json             # Config MC
+│   ├── resources.json        # Ressources MC (drones, fuel, etc.)
+│   └── ...
+├── plans/                    # Plans détaillés
+│   ├── PROTOTYPE_PLAN.md     # Plan 12 semaines
+│   └── SHARED_MODULES_PLAN.md
+└── build/
 ```
 
+**Communication** : Pub/sub via `grove::IIO` - modules indépendants.
+
 ## Getting Started
 
 ### Prerequisites
@@ -114,43 +137,64 @@ cd build
 
 ## Roadmap Développement
 
-### Prototype (3-6 mois) - EN COURS
-- [x] Setup projet GroveEngine
-- [x] Build system fonctionnel
-- [x] Hot-reload validé
-- [ ] Train basique (3 wagons)
-- [ ] Craft simple (1 ressource → 1 drone)
-- [ ] 1 mission combat Rimworld-style
-- [ ] 3-5 events
-- [ ] Loop complet minimal
+### Phase 1 - Fondations (Sem 1-2) - EN COURS
+**Focus** : Modules core game-agnostic
+- [ ] ResourceModule (inventaire, craft 1→1)
+- [ ] StorageModule (save/load)
+- [ ] GameModule v2 (state machine)
+
+### Phase 2 - Train & Resources (Sem 3-4)
+- [ ] TrainBuilderModule (3 wagons, balance)
+- [ ] ResourceModule v2 (10+ ressources, recipes)
+
+### Phase 3 - Combat & Events (Sem 5-8)
+- [ ] CombatModule (1 mission Rimworld-style)
+- [ ] EventModule (5 events scriptés)
+- [ ] ExpeditionModule (lancer expéditions)
+
+### Phase 4 - Integration (Sem 9-12)
+- [ ] UI basique (console ou ImGui)
+- [ ] Balance pass
+- [ ] Loop complet jouable (30 min gameplay)
+
+**Plan détaillé** : Voir `plans/PROTOTYPE_PLAN.md` (12 semaines)
 
 ### MVP (12-18 mois)
-- Train complet (tous wagons)
-- Craft medium depth
-- 5 types missions + 20 events
-- Expedition system
-- Campaign Act 1 jouable
+- Train complet, expedition system, campaign Act 1
 
 ### Full Game (24-36 mois)
-- Polish tous systèmes
-- Campaign complète (4 acts)
-- 100+ events
-- Balancing complet
-- UI/UX polish + Audio
+- Campaign complète, 100+ events, polish UI/Audio
 
 ## Documentation
 
-**Concept Doc complet** : Voir `../couple-repo/Projects/CONCEPT/mobile_command_v2.md`
+- **🎯 Architecture game-agnostic** : `ARCHITECTURE.md` ← **LIRE EN PREMIER**
+- **Plans détaillés** : `plans/PROTOTYPE_PLAN.md`, `plans/SHARED_MODULES_PLAN.md`
+- **Architecture modules** : `docs/MODULES_ARCHITECTURE.md`
+- **Concept complet** : `../couple-repo/Projects/CONCEPT/mobile_command_v2.md`
+- **Instructions dev** : `CLAUDE.md`
 
 ## Status
 
-**PROTOTYPE SETUP** - Version 0.1.0 (1er décembre 2025)
-- ✅ Setup initial du projet
-- ✅ GroveEngine intégré
-- ✅ Build system configuré
-- ✅ Hot-reload fonctionnel
-- 🚧 Prochaine étape : Prototype gameplay
+**PHASE 1 - FONDATIONS** - Version 0.1.0 → 0.2.0
+
+✅ **Complété** :
+- Setup projet + GroveEngine
+- Build system + hot-reload
+- Plans détaillés (12 semaines)
+- Architecture game-agnostic définie
+
+🚧 **En cours** (Semaine 1-2) :
+- ResourceModule (core, game-agnostic)
+- StorageModule (core, game-agnostic)
+- GameModule v2 (MC-specific)
+
+📋 **Prochain** (Semaine 3-4) :
+- TrainBuilderModule
+- ResourceModule v2 (10+ resources)
 
 ---
 
-*Objectif secondaire : Valider GroveEngine en conditions réelles*
+**Objectifs** :
+1. Prototype Mobile Command jouable (12 semaines)
+2. Modules core réutilisables pour WarFactory
+3. Validation GroveEngine en production