Refactor: Complete internationalization and modernization to v2.0.0

Major Changes: - Remove all emojis from UI, code, and documentation for professional appearance - Translate entire codebase from French to English (code, comments, strings, UI) - Simplify template system: 18 templates → single default template - Rename "Mode Liberté Total" to "Enhanced Mode" throughout - Add comprehensive English README with installation and usage guides - Add MIT License (open source, no attribution required) - Update package.json with proper metadata and keywords Breaking Changes: - Template API endpoint changed from /api/templates/:domain/:level to /api/templates/default - All French UI text and notifications replaced with English - Template directory structure simplified Technical Improvements: - Cleaner, more maintainable codebase - Improved internationalization - Better developer experience with English documentation - Professional appearance suitable for production use
2025-10-14 15:05:39 +02:00 · 2025-10-14 15:05:39 +02:00 · aa0a3863b6
commit aa0a3863b6
parent 2846d2feef
31 changed files with 713 additions and 4360 deletions
--- a/21
+++ b/21
@ -0,0 +1,21 @@
 MIT License
 Copyright (c) 2024 Design Journal Contributors
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
 in the Software without restriction, including without limitation the rights
 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:
 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
--- a/README.md
+++ b/README.md
@ -1,393 +1,176 @@
-# 🚀 Conception Assistant
+# Design Journal
-Un assistant intelligent de conception technique avec fonctionnalités IA avancées pour l'analyse, l'amélioration et la gestion de documents de conception.
+A collaborative design documentation tool with AI-powered assistance for technical project management.
-## 📋 Fonctionnalités
+## Features
-### 📝 Gestion des Journaux
+### Document Management
 - Rich text editor for design journals
 - Automatic table of contents generation from headings
 - Real-time Markdown preview with GitHub-style rendering
 - Auto-save functionality with timestamp tracking
 - Version history with undo/redo (Ctrl+Z/Y)
- **Création et édition** de journaux de conception avec éditeur riche
+### AI-Powered Assistant (Mistral AI)
- **Sauvegarde automatique** avec horodatage
+- **Rephrase**: Improve clarity and style of selected text
- **Chargement de journaux** précédents via interface modale
+- **Analyze**: Detect inconsistencies and duplicates in documents
- **Table des matières** dynamique avec navigation intelligente
+- **Advice**: Get constructive improvement suggestions
- **Prévisualisation Markdown** avec rendu professionnel
+- **Enhanced Mode**: Iterative document enrichment with configurable precision (30-90%)
  - Up to 10 iterations of progressive enhancement
  - Real-time streaming feedback
  - Precision control for creative vs. conservative improvements
-### 🤖 Assistant IA Intégré (Mistral AI)
+### User Interface
 - Dark/Light theme with preference persistence
 - Split-panel layout with collapsible sidebars
 - Responsive design for various screen sizes
 - Keyboard shortcuts for common actions
-#### ✨ **Reformulation Intelligente**
+### Export & Import
 - Export to Markdown (.md), PDF, or HTML
 - Import existing Markdown files
 - Default template for quick starts
- Reformulation de texte sélectionné avec prévisualisation
+## Installation
 - Validation avant application
 - Conservation de l'intention originale
-#### 🔍 **Analyse Automatisée**
+### Prerequisites
 - Node.js 16+
 - npm or yarn
 - Mistral API key (optional, for AI features)
- **Détection d'incohérences** dans le document
+### Setup
 - **Vérification de doublons** et redondances
 - **Conseils d'amélioration** personnalisés
 #### 🚀 **Mode Liberté Total** (Révolutionnaire !)
 - **Jusqu'à 10 itérations** d'enrichissement progressif
 - **Contrôle de précision** : 30% (très créatif) à 90% (très précis)
 - **Streaming temps réel** : voir chaque amélioration en direct
 - **Feedback instantané** : explications détaillées pour chaque itération
 - **Document complet** : enrichit TOUT le document à chaque passage
 ### 🎨 Interface & Expérience
 #### 🌙 **Thèmes**
 - **Mode sombre/clair** avec persistance des préférences
 - **Variables CSS** cohérentes pour tous les composants
 - **Basculement instantané** sans rechargement
 #### 👁️ **Mode Prévisualisation**
 - **Toggle édition/visualisation** en un clic
 - **Rendu GitHub Markdown** : titres, listes, code, liens, citations, tables
 - **Support Mermaid** : diagrammes intégrés
 - **Styling professionnel** pour présentation finale
 #### 🧭 **Navigation Avancée**
 - **Table des matières** générée automatiquement
 - **Scroll intelligent** vers les sections avec surbrillance
 - **Historique complet** : Ctrl+Z/Y pour toutes les actions IA
 - **Raccourcis clavier** : Ctrl+S sauvegarde, Tab indentation
 ### 📤 Export & Import
 - **Export Markdown** (.md) natif avec préservation formatage
 - **Export PDF/HTML** professionnel via Puppeteer
 - **Import de fichiers** Markdown avec détection automatique
 - **Templates prédéfinis** (6 domaines × 3 niveaux = 18 templates)
  - 💻 Informatique • 💼 Business • 🎨 Design
  - ⚙️ Ingénierie • 📊 Mathématiques • 🔬 Recherche
 ## ⚙️ Installation
 ### Prérequis
 - **Node.js** 16+
 - **npm** ou **yarn**
 - **Clé API Mistral** (pour les fonctions IA)
 ### Installation
 ```bash
-# Cloner le repository
+# Clone the repository
-git clone https://github.com/votre-repo/conception-assistant.git
+git clone <repository-url>
 cd conception-assistant
-# Installer les dépendances
+# Install dependencies
 npm install
-# Créer le fichier de configuration (optionnel)
+# Create configuration file (optional)
-echo "PORT=3000
+cp .env.example config/.env
-MISTRAL_API_KEY=your_key_here
+# Edit config/.env and add your Mistral API key
 AI_ENABLED=true" > .env
 ```
-### Configuration (Optionnelle)
+### Configuration
-L'application fonctionne sans configuration. Pour activer l'IA, éditez `.env` :
+Create a `config/.env` file with the following (all optional):
 ```env
-# 🌐 Serveur (optionnel)
+# Server Configuration
 PORT=3000
-# 🤖 Mistral AI (requis pour l'IA)
+# Mistral AI Configuration (required for AI features)
 MISTRAL_API_KEY=your_mistral_api_key_here
 MISTRAL_MODEL=mistral-large-latest
 MISTRAL_BASE_URL=https://api.mistral.ai/v1
-# ⚙️ Configuration IA avancée (optionnel)
+# AI Advanced Configuration
 AI_ENABLED=true
 AI_MAX_TOKENS=35000
 AI_TEMPERATURE=0.3
 AI_TOP_P=0.85
 ```
-> **💡 Sans clé API** : L'application fonctionne parfaitement pour la gestion des journaux, seules les fonctions IA sont désactivées.
+> **Note**: The application works perfectly for journal management without an API key. AI features will be disabled if no key is provided.
-### Lancement
+### Running
 ```bash
-# Démarrer l'application
+# Start the application
 npm start
-# Accéder à l'application
+# Access the application
-http://localhost:3000
+# Open http://localhost:3000 in your browser
 ```
-## 🔧 Configuration IA Avancée
+## Usage
-### Paramètres Optimisés pour la Précision
+### Creating a New Journal
 1. Use the main editor to write your content
 2. The table of contents updates automatically
 3. Save with Ctrl+S or the Save button
- **AI_TEMPERATURE=0.3** : Réponses précises et cohérentes
+### Using AI Features
- **AI_MAX_TOKENS=35000** : Support des longs documents
+1. **Rephrase**: Select text → click "Rephrase" button
- **AI_TOP_P=0.85** : Vocabulaire focalisé
+2. **Analysis**: Click "Inconsistencies", "Duplicates", or "Advice" buttons
 3. **Enhanced Mode**:
   - Choose iterations (1-10) and precision (30-90%)
   - Click "Enhanced Mode"
   - Watch real-time streaming improvements
-### Températures Spécialisées par Fonction
+### Keyboard Shortcuts
 - `Ctrl+S` - Save journal
 - `Ctrl+Z` - Undo
 - `Ctrl+Y` or `Ctrl+Shift+Z` - Redo
 - `Tab` - Indent
 - `Esc` - Close panels
- **Reformulation** : 0.2 (très précise)
+## Project Structure
 - **Analyses** : 0.1 (factuelle)
 - **Conseils** : 0.4 (équilibrée)
 - **Mode Liberté Total** : 0.1-0.9 (dynamique selon précision)
 ## 🚀 Mode Liberté Total - Fonctionnement Révolutionnaire
 Le **Mode Liberté Total** transforme votre document avec un contrôle précis de la créativité :
 ### 🎯 **Contrôle de Précision**
 | Niveau | Précision | Comportement | Usage |
 |--------|-----------|--------------|--------|
 | **30%** | Très Créatif | Peut créer 70% de contenu nouveau logique | Brainstorming initial |
 | **50%** | Équilibré | Balance déduction/création 50/50 | Développement standard |
 | **70%** | Conservateur | Principalement basé sur l'existant | Raffinement document |
 | **90%** | Très Précis | Seulement déductions évidentes | Finalisation technique |
 ### 🔄 **Processus Itératif en Temps Réel**
 1. **📊 Analyse** : L'IA évalue le document selon la précision choisie
 2. **🎯 Enrichissement** : Ajoute sections, détails, diagrammes conceptuels
 3. **📡 Streaming** : Vous voyez l'explication en temps réel
 4. **✏️ Application** : Le document est automatiquement mis à jour
 5. **🔄 Itération** : Répétition sur le document enrichi
 6. **✅ Finalisation** : Sauvegarde automatique avec historique
 ### 📈 **Exemple de Session (Précision 70%)**
 ```
 🔄 Itération 1/3 : Analyse du document...
   ✅ Ajout section "Architecture technique détaillée"
   ✅ Développement des "Contraintes de performance"
 🔄 Itération 2/3 : Enrichissement du contenu...
   ✅ Diagrammes de séquence pour les flux principaux
   ✅ Matrice de risques avec plans d'atténuation
 🔄 Itération 3/3 : Finalisation...
   ✅ Plan de tests complet avec critères d'acceptation
   ✅ Métriques de performance et indicateurs clés
 ✅ Mode Liberté Total terminé !
   Document enrichi de 85% avec 3 itérations
 ```
 ## 📖 Utilisation
 ### Créer un Nouveau Journal
 1. Utilisez l'éditeur principal pour rédiger
 2. La table des matières se met à jour automatiquement
 3. Sauvegardez avec **Ctrl+S** ou le bouton 💾
 ### Utiliser l'IA
 1. **Reformulation** : Sélectionnez du texte → bouton "🔄 Reformuler"
 2. **Analyse** : Boutons "🔍 Incohérences", "📋 Doublons", "💡 Conseils"
 3. **Mode Liberté Total** :
   - Choisir **itérations** (1-10) et **précision** (30-90%)
   - Clic sur "🚀 Mode Liberté Total"
   - Suivre le **streaming en temps réel**
 ### Mode Prévisualisation
 1. Cliquez sur **👁️ Visualiser**
 2. Consultez le rendu final professionnel
 3. Cliquez sur **✏️ Éditer** pour revenir à l'édition
 ## 🏗️ Architecture Technique
 ### 📁 Structure du Projet
 ```
 conception-assistant/
-├── app.js                          # ⚡ Serveur principal Express
+├── app.js                   # Express server
-├── package.json                    # 📦 Dépendances et scripts
+├── package.json             # Dependencies and scripts
-├── package-lock.json              # 🔒 Verrouillage des versions
+├── routes/                  # API routes
-├── README.md                      # 📖 Documentation du projet
+│   ├── index.js            # Main routes
-│
+│   ├── api.js              # Journal CRUD operations
-├── 📂 routes/                     # 🛣️ Routes API et logique métier
+│   ├── ai.js               # AI integration (Mistral)
-│   ├── index.js                   # 🏠 Page d'accueil et routes de base
+│   ├── templates.js        # Template management
-│   ├── api.js                     # 📝 CRUD journaux (create, read, update, delete)
+│   └── export.js           # PDF/HTML export
-│   ├── ai.js                      # 🤖 Intelligence Artificielle (Mistral AI)
+├── views/                   # HTML components
-│   ├── templates.js               # 📄 Gestion des templates prédéfinis
+│   ├── page.js             # Main HTML structure
-│   └── export.js                  # 📤 Export PDF/HTML (Puppeteer)
+│   ├── header.js           # Header component
-│
+│   ├── main.js             # Main content area
-├── 📂 views/                      # 🎨 Composants d'interface modulaires
+│   └── footer.js           # Footer component
-│   ├── page.js                    # 📄 Structure HTML principale
+├── assets/                  # Static resources
-│   ├── header.js                  # 🔝 En-tête avec navigation
+│   ├── css/                # Stylesheets
-│   ├── main.js                    # 🎯 Zone principale (éditeur + assistant IA)
+│   └── js/                 # Client-side JavaScript
-│   └── footer.js                  # 🔽 Pied de page minimal
+├── templates/              # Document templates
-│
+│   └── default.md          # Default template
-├── 📂 assets/                     # 🎨 Ressources statiques
+└── data/                   # Journal storage
-│   ├── css/
+    └── journals_*.json     # Saved journals
 │   │   ├── style.css              # 🎨 Styles principaux et thèmes
 │   │   └── github-preview.css     # 👁️ Style GitHub pour prévisualisation
 │   └── js/
 │       └── app.js                 # ⚙️ Application frontend (4000+ lignes)
 │
 ├── 📂 templates/                  # 📝 Templates de conception prédéfinis
 │   ├── informatique/              # 💻 Templates IT (simple, détaillé, complet)
 │   ├── business/                  # 💼 Templates business
 │   ├── design/                    # 🎨 Templates design
 │   ├── ingenierie/               # ⚙️ Templates ingénierie
 │   ├── math/                     # 📊 Templates mathématiques
 │   └── recherche/                # 🔬 Templates recherche
 │
 └── 📂 data/                      # 💾 Stockage des journaux utilisateur
    └── journals_*.json           # 📔 Fichiers JSON des journaux
 ```
-### 🔧 Architecture Technique Détaillée
+## AI Configuration
-#### 🖥️ **Backend (Node.js + Express.js)**
+### Temperature Settings by Feature
 - **Rephrase**: 0.2 (very precise)
 - **Analysis**: 0.1 (factual)
 - **Advice**: 0.4 (balanced)
 - **Enhanced Mode**: 0.1-0.9 (dynamic based on precision setting)
-| Composant | Fichier | Responsabilité | Technologies |
+### Enhanced Mode Precision Levels
-|-----------|---------|----------------|--------------|
+| Level | Description | Behavior | Use Case |
-| **Serveur Principal** | `app.js` | Configuration Express, middleware, routes | Express.js 4.18+ |
+|-------|-------------|----------|----------|
-| **API Journaux** | `routes/api.js` | CRUD journaux, stockage JSON | File System, UUID |
+| 30% | Very Creative | Can create 70% new logical content | Initial brainstorming |
-| **Intelligence Artificielle** | `routes/ai.js` | Intégration Mistral AI, streaming | Mistral AI API, Server-Sent Events |
+| 50% | Balanced | 50/50 deduction/creation | Standard development |
-| **Templates** | `routes/templates.js` | Gestion templates par domaine | File System |
+| 70% | Conservative | Primarily based on existing content | Document refinement |
-| **Export** | `routes/export.js` | Génération PDF/HTML | Puppeteer |
+| 90% | Very Precise | Only obvious deductions | Technical finalization |
-#### 🎨 **Frontend (Vanilla JavaScript)**
+## Technology Stack
-| Composant | Fichier | Responsabilité | Fonctionnalités |
+### Backend
-|-----------|---------|----------------|-----------------|
+- **Node.js** - JavaScript runtime
-| **Application Principale** | `assets/js/app.js` | Logique métier frontend | Éditeur, IA, historique, navigation |
+- **Express.js** - Web framework
-| **Interface Modulaire** | `views/*.js` | Composants HTML | Header, main, footer |
+- **Mistral AI** - Language model API
-| **Styles** | `assets/css/*.css` | Thèmes et présentation | CSS Variables, GitHub Preview |
+- **Puppeteer** - PDF generation
-#### 🤖 **Système IA Avancé**
+### Frontend
 - **Vanilla JavaScript** - No framework dependencies
 - **Marked.js** - Markdown parsing
 - **Mermaid.js** - Diagram rendering
 - **CSS Variables** - Dynamic theming
-| Fonctionnalité | Endpoint | Méthode | Streaming | Précision |
+## License
 |---------------|----------|---------|-----------|-----------|
 | **Reformulation** | `/api/ai/rephrase` | POST | ❌ | 90%+ |
 | **Incohérences** | `/api/ai/check-inconsistencies` | POST | ❌ | Factuelle |
 | **Doublons** | `/api/ai/check-duplications` | POST | ❌ | Factuelle |
 | **Conseils** | `/api/ai/give-advice` | POST | ❌ | Équilibrée |
 | **Mode Liberté Total** | `/api/ai/liberty-mode` | POST | ✅ SSE | Configurable 30-90% |
-### ⚡ **Technologies & Stack**
+MIT License - see LICENSE file for details
-#### **Core Dependencies**
+## Contributing
-```json
+Contributions are welcome! Please feel free to submit issues or pull requests.
 {
  "express": "^4.18.2",           // 🌐 Serveur web
  "dotenv": "^17.2.2",            // ⚙️ Variables d'environnement
  "puppeteer": "^24.22.3",        // 📄 Génération PDF
  "uuid": "^13.0.0"               // 🆔 Identifiants uniques
 }
 ```
-#### **API Externes**
+## Open Source
- **Mistral AI** : Modèles de langage avancés
+This project is open source and available under the MIT License. No attribution required.
  - `mistral-large-latest` : Analyse et génération
  - Temperature dynamique : 0.1-0.9 selon la tâche
  - Max tokens : 35000 pour longs documents
 #### **Stockage & Persistance**
 - **Journaux** : Fichiers JSON avec UUID
 - **Préférences** : LocalStorage navigateur
 - **Templates** : Fichiers Markdown statiques
 - **Exports** : Génération temporaire PDF/HTML
 ### 🔄 **Flux de Données**
 #### **Mode Liberté Total (Streaming)**
 ```mermaid
 sequenceDiagram
    participant User as 👤 Utilisateur
    participant Frontend as 🌐 Frontend
    participant Backend as ⚙️ Backend
    participant AI as 🤖 Mistral AI
    User->>Frontend: Clic "Mode Liberté Total"
    Frontend->>Backend: POST /api/ai/liberty-mode (SSE)
    loop Pour chaque itération
        Backend->>AI: Envoi document + précision
        AI->>Backend: Explication + Markdown amélioré
        Backend->>Frontend: Stream données (SSE)
        Frontend->>User: Affichage temps réel + MAJ éditeur
    end
    Backend->>Frontend: Signal fin (completed: true)
    Frontend->>User: Notification terminée
 ```
 #### **Gestion des Journaux**
 ```mermaid
 flowchart TD
    A[👤 Utilisateur] --> B[✏️ Éditeur]
    B --> C[💾 Sauvegarde Auto]
    C --> D[📁 data/journals_UUID.json]
    A --> E[📂 Charger Journal]
    E --> F[📋 Liste Journaux]
    F --> G[🔄 Chargement Contenu]
    G --> B
    B --> H[👁️ Mode Prévisualisation]
    H --> I[🎨 Rendu GitHub Markdown]
    I --> B
 ```
 ### 🛡️ **Sécurité & Configuration**
 #### **Variables d'Environnement**
 ```env
 # Serveur
 PORT=3000
 # Mistral AI
 MISTRAL_API_KEY=your_key_here
 MISTRAL_MODEL=mistral-large-latest
 MISTRAL_BASE_URL=https://api.mistral.ai/v1
 # IA
 AI_ENABLED=true
 AI_MAX_TOKENS=35000
 AI_TEMPERATURE=0.3
 AI_TOP_P=0.85
 ```
 #### **Gestion d'Erreur Robuste**
 - **Backend** : Try-catch sur toutes les routes
 - **Frontend** : Gestion d'erreur asynchrone
 - **IA** : Fallback et retry automatique
 - **Streaming** : Gestion déconnexion SSE
 ### 🚀 **Performance & Optimisations**
 | Aspect | Implémentation | Bénéfice |
 |--------|----------------|----------|
 | **Debouncing** | Table des matières, sauvegarde | Réduit calculs inutiles |
 | **Streaming SSE** | Mode Liberté Total | Feedback temps réel |
 | **Cache LocalStorage** | Préférences thème | Persistance locale |
 | **Lazy Loading** | Templates à la demande | Chargement optimisé |
 | **CSS Variables** | Thèmes dynamiques | Basculement instantané |
 ## 🤝 Contribution
 1. **Fork** le projet
 2. **Créer** une branche feature (`git checkout -b feature/nouvelle-fonctionnalite`)
 3. **Commit** vos changements (`git commit -am 'Ajout nouvelle fonctionnalité'`)
 4. **Push** vers la branche (`git push origin feature/nouvelle-fonctionnalite`)
 5. **Créer** une Pull Request
 --
 **Conception Assistant** - Votre partenaire intelligent pour la conception technique ! 🚀
--- a/assets/css/style.css
+++ b/assets/css/style.css
@ -526,10 +526,10 @@ button.success:hover {
 /* Main content */
 main {
  display: grid;
-  grid-template-columns: 300px 1fr 350px;
+  grid-template-columns: 300px 1fr 400px;
  gap: 2rem;
  padding: 2rem;
-  max-width: 1400px;
+  max-width: 100%;
  margin: 0 auto;
  min-height: calc(100vh - 140px);
 }
--- a/assets/js/app.js
+++ b/assets/js/app.js
--- a/package.json
+++ b/package.json
@ -1,10 +1,28 @@
 {
-  "name": "conception-assistant",
+  "name": "design-journal",
-  "version": "1.0.0",
+  "version": "2.0.0",
  "description": "A collaborative design documentation tool with AI-powered assistance for technical project management",
  "main": "app.js",
  "scripts": {
-    "start": "node app.js",
+    "start": "node app.js"
-    "test": "node tests/all.test.js"
+  },
  "keywords": [
    "design",
    "journal",
    "documentation",
    "markdown",
    "ai",
    "mistral",
    "collaboration"
  ],
  "author": "Design Journal Contributors",
  "license": "MIT",
  "repository": {
    "type": "git",
    "url": "https://github.com/yourusername/design-journal.git"
  },
  "engines": {
    "node": ">=16.0.0"
  },
  "dependencies": {
    "dotenv": "^17.2.2",
--- a/routes/ai.js
+++ b/routes/ai.js
@ -2,32 +2,32 @@ const express = require('express');
 const router = express.Router();
 require('dotenv').config({ path: './config/.env' });
-// Configuration Mistral AI
+// Mistral AI Configuration
 const MISTRAL_API_KEY = process.env.MISTRAL_API_KEY;
 const MISTRAL_BASE_URL = process.env.MISTRAL_BASE_URL || 'https://api.mistral.ai/v1';
 const MISTRAL_MODEL = process.env.MISTRAL_MODEL || 'mistral-large-latest';
 const AI_ENABLED = process.env.AI_ENABLED === 'true';
-// Middleware de vérification
+// Verification middleware
 function checkAIEnabled(req, res, next) {
  if (!AI_ENABLED) {
    return res.status(503).json({
      success: false,
-      error: 'Les fonctionnalités IA sont désactivées'
+      error: 'AI features are disabled'
    });
  }
  if (!MISTRAL_API_KEY) {
    return res.status(500).json({
      success: false,
-      error: 'Clé API Mistral non configurée'
+      error: 'Mistral API key not configured'
    });
  }
  next();
 }
-// Fonction pour appeler l'API Mistral
+// Function to call Mistral API
 async function callMistralAPI(messages, temperature = null) {
  try {
    const response = await fetch(`${MISTRAL_BASE_URL}/chat/completions`, {
@ -47,18 +47,18 @@ async function callMistralAPI(messages, temperature = null) {
    if (!response.ok) {
      const error = await response.text();
-      throw new Error(`Erreur API Mistral: ${response.status} - ${error}`);
+      throw new Error(`Mistral API Error: ${response.status} - ${error}`);
    }
    const data = await response.json();
    return data.choices[0].message.content;
  } catch (error) {
-    console.error('Erreur Mistral API:', error);
+    console.error('Mistral API Error:', error);
    throw error;
  }
 }
-// POST /api/ai/rephrase - Reformuler du texte
+// POST /api/ai/rephrase - Rephrase text
 router.post('/rephrase', checkAIEnabled, async (req, res) => {
  try {
    const { text, context = '' } = req.body;
@ -66,32 +66,32 @@ router.post('/rephrase', checkAIEnabled, async (req, res) => {
    if (!text || text.trim().length === 0) {
      return res.status(400).json({
        success: false,
-        error: 'Texte à reformuler requis'
+        error: 'Text to rephrase is required'
      });
    }
    const messages = [
      {
        role: 'system',
-        content: `Tu es un assistant spécialisé dans la reformulation de textes techniques et de conception.
+        content: `You are an assistant specialized in rephrasing technical and design texts.
-        RÈGLES STRICTES :
+        STRICT RULES:
-        1. Reformule le texte pour améliorer la clarté, le style et la fluidité
+        1. Rephrase the text to improve clarity, style, and fluency
-        2. Conserve le niveau technique et tous les détails importants
+        2. Preserve the technical level and all important details
-        3. Ne réponds QUE avec le texte reformulé final
+        3. Respond ONLY with the final rephrased text
-        4. Aucune introduction, conclusion, explication ou commentaire
+        4. No introduction, conclusion, explanation, or commentary
-        5. Ne commence pas par "Voici", "Le texte reformulé" ou autre préambule
+        5. Do not start with "Here is", "The rephrased text" or other preamble
-        6. Commence directement par le contenu reformulé
+        6. Start directly with the rephrased content
-        ${context ? `Contexte du document: ${context}` : ''}`
+        ${context ? `Document context: ${context}` : ''}`
      },
      {
        role: 'user',
-        content: `Reformule ce texte: "${text}"`
+        content: `Rephrase this text: "${text}"`
      }
    ];
-    const result = await callMistralAPI(messages, 0.2); // Reformulation précise
+    const result = await callMistralAPI(messages, 0.2); // Precise rephrasing
    res.json({
      success: true,
@ -102,15 +102,15 @@ router.post('/rephrase', checkAIEnabled, async (req, res) => {
    });
  } catch (error) {
-    console.error('Erreur reformulation:', error);
+    console.error('Rephrasing error:', error);
    res.status(500).json({
      success: false,
-      error: 'Erreur lors de la reformulation: ' + error.message
+      error: 'Error during rephrasing: ' + error.message
    });
  }
 });
-// POST /api/ai/check-inconsistencies - Vérifier les incohérences
+// POST /api/ai/check-inconsistencies - Check for inconsistencies
 router.post('/check-inconsistencies', checkAIEnabled, async (req, res) => {
  try {
    const { content } = req.body;
@ -118,30 +118,30 @@ router.post('/check-inconsistencies', checkAIEnabled, async (req, res) => {
    if (!content || content.trim().length === 0) {
      return res.status(400).json({
        success: false,
-        error: 'Contenu à analyser requis'
+        error: 'Content to analyze is required'
      });
    }
    const messages = [
      {
        role: 'system',
-        content: `Tu es un expert en analyse de documents de conception technique.
+        content: `You are an expert in technical design document analysis.
-        Analyse le document suivant et identifie toutes les incohérences potentielles :
+        Analyze the following document and identify all potential inconsistencies:
-        - Contradictions dans les informations
+        - Contradictions in information
-        - Décisions qui se contredisent
+        - Conflicting decisions
-        - Incohérences dans la terminologie
+        - Inconsistencies in terminology
-        - Problèmes logiques dans l'architecture ou les choix
+        - Logical issues in architecture or choices
-        Réponds directement avec ton analyse détaillée des incohérences trouvées.`
+        Respond directly with your detailed analysis of the inconsistencies found.`
      },
      {
        role: 'user',
-        content: `Analyse ce document pour détecter les incohérences:\n\n${content}`
+        content: `Analyze this document to detect inconsistencies:\n\n${content}`
      }
    ];
-    const result = await callMistralAPI(messages, 0.1); // Analyse précise et factuelle
+    const result = await callMistralAPI(messages, 0.1); // Precise and factual analysis
    res.json({
      success: true,
@ -151,15 +151,15 @@ router.post('/check-inconsistencies', checkAIEnabled, async (req, res) => {
    });
  } catch (error) {
-    console.error('Erreur analyse incohérences:', error);
+    console.error('Inconsistencies analysis error:', error);
    res.status(500).json({
      success: false,
-      error: 'Erreur lors de l\'analyse: ' + error.message
+      error: 'Error during analysis: ' + error.message
    });
  }
 });
-// POST /api/ai/check-duplications - Vérifier les doublons
+// POST /api/ai/check-duplications - Check for duplications
 router.post('/check-duplications', checkAIEnabled, async (req, res) => {
  try {
    const { content } = req.body;
@ -167,31 +167,31 @@ router.post('/check-duplications', checkAIEnabled, async (req, res) => {
    if (!content || content.trim().length === 0) {
      return res.status(400).json({
        success: false,
-        error: 'Contenu à analyser requis'
+        error: 'Content to analyze is required'
      });
    }
    const messages = [
      {
        role: 'system',
-        content: `Tu es un expert en analyse de contenu.
+        content: `You are a content analysis expert.
-        Analyse le document suivant pour identifier :
+        Analyze the following document to identify:
-        - Les informations répétées ou redondantes
+        - Repeated or redundant information
-        - Les sections qui traitent du même sujet
+        - Sections that cover the same topic
-        - Les explications dupliquées
+        - Duplicated explanations
-        - Les concepts présentés plusieurs fois
+        - Concepts presented multiple times
-        Propose des suggestions pour éliminer ces duplications tout en préservant les informations importantes.
+        Suggest ways to eliminate these duplications while preserving important information.
-        Réponds directement avec ton analyse et tes suggestions.`
+        Respond directly with your analysis and suggestions.`
      },
      {
        role: 'user',
-        content: `Analyse ce document pour détecter les duplications:\n\n${content}`
+        content: `Analyze this document to detect duplications:\n\n${content}`
      }
    ];
-    const result = await callMistralAPI(messages, 0.1); // Analyse précise et factuelle
+    const result = await callMistralAPI(messages, 0.1); // Precise and factual analysis
    res.json({
      success: true,
@ -201,51 +201,51 @@ router.post('/check-duplications', checkAIEnabled, async (req, res) => {
    });
  } catch (error) {
-    console.error('Erreur analyse duplications:', error);
+    console.error('Duplications analysis error:', error);
    res.status(500).json({
      success: false,
-      error: 'Erreur lors de l\'analyse: ' + error.message
+      error: 'Error during analysis: ' + error.message
    });
  }
 });
-// POST /api/ai/give-advice - Donner des conseils
+// POST /api/ai/give-advice - Give advice
 router.post('/give-advice', checkAIEnabled, async (req, res) => {
  try {
-    const { content, domain = 'général' } = req.body;
+    const { content, domain = 'general' } = req.body;
    if (!content || content.trim().length === 0) {
      return res.status(400).json({
        success: false,
-        error: 'Contenu à analyser requis'
+        error: 'Content to analyze is required'
      });
    }
    const messages = [
      {
        role: 'system',
-        content: `Tu es un consultant expert en conception et architecture technique dans le domaine: ${domain}.
+        content: `You are an expert consultant in design and technical architecture in the domain: ${domain}.
-        Analyse le document de conception fourni et donne des conseils constructifs pour l'améliorer.
+        Analyze the provided design document and give constructive advice to improve it.
-        Concentre-toi sur :
+        Focus on:
-        - La complétude de la documentation
+        - Documentation completeness
-        - La clarté des explications
+        - Clarity of explanations
-        - L'organisation du contenu
+        - Content organization
-        - Les bonnes pratiques du domaine
+        - Domain best practices
-        - Les points manquants importants
+        - Important missing points
-        - Les suggestions d'amélioration concrètes
+        - Concrete improvement suggestions
-        Sois constructif et pratique dans tes recommandations.
+        Be constructive and practical in your recommendations.
-        Réponds directement avec tes conseils et suggestions d'amélioration.`
+        Respond directly with your advice and improvement suggestions.`
      },
      {
        role: 'user',
-        content: `Analyse ce document de conception et donne des conseils pour l'améliorer:\n\n${content}`
+        content: `Analyze this design document and provide advice to improve it:\n\n${content}`
      }
    ];
-    const result = await callMistralAPI(messages, 0.4); // Conseils équilibrés
+    const result = await callMistralAPI(messages, 0.4); // Balanced advice
    res.json({
      success: true,
@ -255,30 +255,30 @@ router.post('/give-advice', checkAIEnabled, async (req, res) => {
    });
  } catch (error) {
-    console.error('Erreur conseils:', error);
+    console.error('Advice error:', error);
    res.status(500).json({
      success: false,
-      error: 'Erreur lors de l\'analyse: ' + error.message
+      error: 'Error during analysis: ' + error.message
    });
  }
 });
-// POST /api/ai/liberty-mode - Mode liberté total (génération itérative)
+// POST /api/ai/liberty-mode - Enhanced mode (iterative generation)
 router.post('/liberty-mode', checkAIEnabled, async (req, res) => {
  try {
-    const { content, iterations = 1, precision = 70, focus = 'conception' } = req.body;
+    const { content, iterations = 1, precision = 70, focus = 'design' } = req.body;
    if (!content || content.trim().length === 0) {
      return res.status(400).json({
        success: false,
-        error: 'Contenu de base requis'
+        error: 'Base content is required'
      });
    }
-    const maxIterations = Math.min(parseInt(iterations), 10); // Limite à 10 itérations
+    const maxIterations = Math.min(parseInt(iterations), 10); // Limit to 10 iterations
-    const precisionPercent = Math.min(Math.max(parseInt(precision), 10), 100); // Entre 10% et 100%
+    const precisionPercent = Math.min(Math.max(parseInt(precision), 10), 100); // Between 10% and 100%
-    // Configuration streaming pour réponses en temps réel
+    // Configure streaming for real-time responses
    res.writeHead(200, {
      'Content-Type': 'text/event-stream',
      'Cache-Control': 'no-cache',
@ -293,60 +293,60 @@ router.post('/liberty-mode', checkAIEnabled, async (req, res) => {
        const messages = [
          {
            role: 'system',
-            content: `Tu es un expert en conception technique avec mode "Liberté Total".
+            content: `You are a technical design expert with "Enhanced Mode".
-            MISSION: Améliore et enrichis le document en respectant EXACTEMENT ce niveau de précision: ${precisionPercent}%
+            MISSION: Improve and enrich the document respecting EXACTLY this precision level: ${precisionPercent}%
-            RÈGLES DE PRÉCISION:
+            PRECISION RULES:
-            - À ${precisionPercent}%: Tu peux déduire et ajouter du contenu à hauteur de ${precisionPercent}% basé sur les informations existantes
+            - At ${precisionPercent}%: You can deduce and add content up to ${precisionPercent}% based on existing information
-            - À ${100 - precisionPercent}%: Tu peux créer du contenu logique et pertinent même sans info explicite dans le texte
+            - At ${100 - precisionPercent}%: You can create logical and relevant content even without explicit info in the text
-            CONSIGNES:
+            INSTRUCTIONS:
-            1. Enrichis TOUT le document de manière cohérente
+            1. Enrich ALL of the document consistently
-            2. Ajoute sections, détails, explications, diagrammes conceptuels
+            2. Add sections, details, explanations, conceptual diagrams
-            3. Développe les idées existantes avec la créativité autorisée
+            3. Develop existing ideas with the allowed creativity
-            4. Maintiens la structure logique
+            4. Maintain logical structure
-            RÉPONSE OBLIGATOIRE EN 2 PARTIES SÉPARÉES PAR "---SPLIT---":
+            MANDATORY RESPONSE IN 2 PARTS SEPARATED BY "---SPLIT---":
-            ## 📊 Explication (Itération ${i + 1}/${maxIterations})
+            ## Analysis (Iteration ${i + 1}/${maxIterations})
-            [Explique les améliorations apportées, les sections ajoutées, le raisonnement]
+            [Explain the improvements made, sections added, reasoning]
            ---SPLIT---
-            [LE DOCUMENT MARKDOWN COMPLET ET AMÉLIORÉ - SANS TITRE "## Document" - DIRECTEMENT LE CONTENU]
+            [THE COMPLETE AND IMPROVED MARKDOWN DOCUMENT - WITHOUT "## Document" TITLE - DIRECTLY THE CONTENT]
            Focus: ${focus}
-            Précision: ${precisionPercent}%`
+            Precision: ${precisionPercent}%`
          },
          {
            role: 'user',
-            content: `Document à améliorer (Itération ${i + 1}):\n\n${currentContent}`
+            content: `Document to improve (Iteration ${i + 1}):\n\n${currentContent}`
          }
        ];
-        // Temperature basée sur la précision (plus créatif = température plus élevée)
+        // Temperature based on precision (more creative = higher temperature)
-        const temperature = (100 - precisionPercent) / 100 * 0.8 + 0.1; // Entre 0.1 et 0.9
+        const temperature = (100 - precisionPercent) / 100 * 0.8 + 0.1; // Between 0.1 and 0.9
        const result = await callMistralAPI(messages, temperature);
-        // Séparer l'explication du markdown
+        // Separate explanation from markdown
        const parts = result.split('---SPLIT---');
        let explanation = '';
-        let newMarkdown = currentContent; // Par défaut, garder l'ancien contenu
+        let newMarkdown = currentContent; // Default, keep old content
        if (parts.length >= 2) {
          explanation = parts[0].trim();
          newMarkdown = parts[1].trim();
-          // Mettre à jour pour la prochaine itération
+          // Update for next iteration
          currentContent = newMarkdown;
        } else {
-          // Fallback si pas de split trouvé
+          // Fallback if no split found
          explanation = result;
        }
-        // Envoyer la réponse de cette itération
+        // Send this iteration's response
        const iterationData = {
          iteration: i + 1,
          explanation: explanation,
@ -356,15 +356,15 @@ router.post('/liberty-mode', checkAIEnabled, async (req, res) => {
        res.write(`data: ${JSON.stringify(iterationData)}\n\n`);
-        // Petit délai pour permettre l'affichage côté client
+        // Small delay to allow client-side display
        await new Promise(resolve => setTimeout(resolve, 500));
      } catch (iterationError) {
-        console.error(`Erreur itération ${i + 1}:`, iterationError);
+        console.error(`Iteration ${i + 1} error:`, iterationError);
        const errorData = {
          iteration: i + 1,
-          error: `Erreur itération ${i + 1}: ${iterationError.message}`,
+          error: `Iteration ${i + 1} error: ${iterationError.message}`,
          completed: true
        };
@ -373,7 +373,7 @@ router.post('/liberty-mode', checkAIEnabled, async (req, res) => {
      }
    }
-    // Signal de fin
+    // End signal
    const finalData = {
      completed: true,
      totalIterations: maxIterations,
@ -384,10 +384,10 @@ router.post('/liberty-mode', checkAIEnabled, async (req, res) => {
    res.end();
  } catch (error) {
-    console.error('Erreur mode liberté total:', error);
+    console.error('Enhanced mode error:', error);
    const errorData = {
-      error: 'Erreur lors de la génération: ' + error.message,
+      error: 'Error during generation: ' + error.message,
      completed: true
    };
@ -396,7 +396,7 @@ router.post('/liberty-mode', checkAIEnabled, async (req, res) => {
  }
 });
-// GET /api/ai/status - Statut de l'IA
+// GET /api/ai/status - AI status
 router.get('/status', (req, res) => {
  res.json({
    success: true,
--- a/routes/api.js
+++ b/routes/api.js
@ -4,23 +4,23 @@ const fs = require('fs');
 const path = require('path');
 const { v4: uuidv4 } = require('uuid');
-// Importer le module d'export
+// Import export module
 const exportRouter = require('./export');
 function modifMd(id, modifications) {
-  if (id === undefined) throw new Error('id obligatoire');
+  if (id === undefined) throw new Error('id required');
-  if (!Array.isArray(modifications) || modifications.length === 0) throw new Error('modifications requises');
+  if (!Array.isArray(modifications) || modifications.length === 0) throw new Error('modifications required');
  const dataDir = path.resolve(__dirname, '../data');
  const mapPath = path.join(dataDir, 'uuid_map.json');
-  if (!fs.existsSync(mapPath)) throw new Error('uuid_map.json inexistant');
+  if (!fs.existsSync(mapPath)) throw new Error('uuid_map.json does not exist');
  const map = JSON.parse(fs.readFileSync(mapPath, 'utf8'));
  const uuid = map[id];
-  if (!uuid) throw new Error(`Aucun fichier pour l'id ${id}`);
+  if (!uuid) throw new Error(`No file for id ${id}`);
  const mdPath = path.join(dataDir, `${uuid}.md`);
-  if (!fs.existsSync(mdPath)) throw new Error('Fichier markdown inexistant');
+  if (!fs.existsSync(mdPath)) throw new Error('Markdown file does not exist');
  let lignes = fs.readFileSync(mdPath, 'utf8').split('\n');
  modifications = modifications.slice().sort((a, b) => a.debut - b.debut);
@ -31,7 +31,7 @@ function modifMd(id, modifications) {
    let fin = m.fin + offset;
    const remplacement = Array.isArray(m.contenu) ? m.contenu : m.contenu.split('\n');
    if (debut < 0 || fin >= lignes.length || debut > fin)
-      throw new Error('Plage invalide (début/fin) pour une modification');
+      throw new Error('Invalid range (start/end) for a modification');
    const avant = lignes.slice(0, debut);
    const apres = lignes.slice(fin + 1);
@ -45,7 +45,7 @@ function modifMd(id, modifications) {
 }
-function createMd(markdownContent = "# Titre\nContenu...") {
+function createMd(markdownContent = "# Title\nContent...") {
  const uuid = uuidv4();
  const dataDir = path.resolve(__dirname, '../data');
@ -83,11 +83,11 @@ function readMd(id = undefined) {
  if (id !== undefined) {
    const uuid = map[id];
    if (!uuid) {
-      throw new Error(`Aucun fichier trouvé pour l'id ${id}`);
+      throw new Error(`No file found for id ${id}`);
    }
    const mdPath = path.join(dataDir, `${uuid}.md`);
    if (!fs.existsSync(mdPath)) {
-      throw new Error(`Le fichier ${mdPath} n’existe pas`);
+      throw new Error(`File ${mdPath} does not exist`);
    }
    const markdownContent = fs.readFileSync(mdPath, 'utf8');
    return [{ id, uuid, path: mdPath, markdownContent }];
@ -105,30 +105,30 @@ function readMd(id = undefined) {
 }
 function updateMd(id, newMarkdownContent) {
-  if (id === undefined) throw new Error('id obligatoire');
+  if (id === undefined) throw new Error('id required');
  const dataDir = path.resolve(__dirname, '../data');
  const mapPath = path.join(dataDir, 'uuid_map.json');
-  if (!fs.existsSync(mapPath)) throw new Error('uuid_map.json inexistant');
+  if (!fs.existsSync(mapPath)) throw new Error('uuid_map.json does not exist');
  let map = JSON.parse(fs.readFileSync(mapPath, 'utf8'));
  const uuid = map[id];
-  if (!uuid) throw new Error(`Aucun fichier trouvé pour l'id ${id}`);
+  if (!uuid) throw new Error(`No file found for id ${id}`);
  const mdPath = path.join(dataDir, `${uuid}.md`);
-  if (!fs.existsSync(mdPath)) throw new Error('Le fichier markdown n\'existe pas');
+  if (!fs.existsSync(mdPath)) throw new Error('Markdown file does not exist');
  fs.writeFileSync(mdPath, newMarkdownContent, { encoding: 'utf8', flag: 'w' });
  return { id, uuid, path: mdPath, newMarkdownContent };
 }
 function deteMd(id) {
-  if (id === undefined) throw new Error('id obligatoire');
+  if (id === undefined) throw new Error('id required');
  const dataDir = path.resolve(__dirname, '../data');
  const mapPath = path.join(dataDir, 'uuid_map.json');
-  if (!fs.existsSync(mapPath)) throw new Error('uuid_map.json inexistant');
+  if (!fs.existsSync(mapPath)) throw new Error('uuid_map.json does not exist');
  let map = JSON.parse(fs.readFileSync(mapPath, 'utf8'));
  const uuid = map[id];
-  if (!uuid) throw new Error(`Aucun fichier trouvé pour l'id ${id}`);
+  if (!uuid) throw new Error(`No file found for id ${id}`);
  const mdPath = path.join(dataDir, `${uuid}.md`);
  if (fs.existsSync(mdPath)) fs.unlinkSync(mdPath);
@ -138,7 +138,7 @@ function deteMd(id) {
  return { id, deleted: true };
 }
-// GET /api/journals - Récupérer tous les journaux
+// GET /api/journals - Get all journals
 router.get('/journals', (req, res) => {
  res.json({
    success: true,
@ -146,7 +146,7 @@ router.get('/journals', (req, res) => {
  });
 });
-// POST /api/journals - Créer un nouveau journal
+// POST /api/journals - Create a new journal
 router.post('/journals', (req, res) => {
  const { content } = req.body;
@ -156,7 +156,7 @@ router.post('/journals', (req, res) => {
  });
 });
-// GET /api/journals/:id - Récupérer un journal spécifique
+// GET /api/journals/:id - Get a specific journal
 router.get('/journals/:id', (req, res) => {
  const { id } = req.params;
@ -166,7 +166,7 @@ router.get('/journals/:id', (req, res) => {
  });
 });
-// PUT /api/journals/:id - Mettre à jour un journal
+// PUT /api/journals/:id - Update a journal
 router.put('/journals/:id', (req, res) => {
  const { id } = req.params;
  const { content, modifications } = req.body;
@ -174,15 +174,15 @@ router.put('/journals/:id', (req, res) => {
  try {
    let result;
    if (content) {
-      // Mise à jour complète du contenu
+      // Complete content update
      result = updateMd(id, content);
    } else if (modifications) {
-      // Modifications partielles (pour compatibilité future)
+      // Partial modifications (for future compatibility)
      result = modifMd(id, modifications);
    } else {
      return res.status(400).json({
        success: false,
-        error: 'Content ou modifications requis'
+        error: 'Content or modifications required'
      });
    }
@ -198,7 +198,7 @@ router.put('/journals/:id', (req, res) => {
  }
 });
-// DELETE /api/journals/:id - Supprimer un journal
+// DELETE /api/journals/:id - Delete a journal
 router.delete('/journals/:id', (req, res) => {
  const { id } = req.params;
@ -208,7 +208,7 @@ router.delete('/journals/:id', (req, res) => {
  });
 });
-// Intégrer les routes d'export
+// Integrate export routes
 router.use('/export', exportRouter);
 module.exports = router;
--- a/routes/export.js
+++ b/routes/export.js
@ -3,23 +3,23 @@ const router = express.Router();
 const puppeteer = require('puppeteer');
 const path = require('path');
-// POST /api/export/pdf - Générer un PDF depuis le contenu markdown
+// POST /api/export/pdf - Generate PDF from markdown content
 router.post('/pdf', async (req, res) => {
-  const { content, title = 'Journal de Conception' } = req.body;
+  const { content, title = 'Design Journal' } = req.body;
  if (!content || content.trim() === '') {
    return res.status(400).json({
      success: false,
-      error: 'Contenu requis pour générer le PDF'
+      error: 'Content required to generate PDF'
    });
  }
  let browser;
  try {
-    // Convertir le markdown en HTML avec styles
+    // Convert markdown to HTML with styles
    const htmlContent = generateStyledHTML(content, title);
-    // Lancer Puppeteer
+    // Launch Puppeteer
    browser = await puppeteer.launch({
      headless: true,
      args: ['--no-sandbox', '--disable-setuid-sandbox']
@ -27,16 +27,16 @@ router.post('/pdf', async (req, res) => {
    const page = await browser.newPage();
-    // Définir le contenu HTML
+    // Set HTML content
    await page.setContent(htmlContent, {
      waitUntil: 'domcontentloaded',
      timeout: parseInt(process.env.PDF_TIMEOUT) || 30000
    });
-    // Attendre que Mermaid soit chargé et les diagrammes rendus
+    // Wait for Mermaid to load and diagrams to render
    await new Promise(resolve => setTimeout(resolve, 2000));
-    // Vérifier si des diagrammes Mermaid existent et attendre qu'ils se chargent
+    // Check if Mermaid diagrams exist and wait for them to load
    try {
      await page.waitForFunction(() => {
        const mermaidElements = document.querySelectorAll('.mermaid');
@ -49,7 +49,7 @@ router.post('/pdf', async (req, res) => {
      console.log('Timeout waiting for Mermaid, proceeding...');
    }
-    // Générer le PDF
+    // Generate PDF
    const pdfBuffer = await page.pdf({
      format: 'A4',
      margin: {
@ -67,23 +67,23 @@ router.post('/pdf', async (req, res) => {
      `,
      footerTemplate: `
        <div style="font-size: 10px; width: 100%; text-align: center; color: #666; margin-bottom: 1cm;">
-          <span>Page <span class="pageNumber"></span> sur <span class="totalPages"></span> - Généré le ${new Date().toLocaleDateString('fr-FR')}</span>
+          <span>Page <span class="pageNumber"></span> of <span class="totalPages"></span> - Generated on ${new Date().toLocaleDateString('en-US')}</span>
        </div>
      `
    });
    await browser.close();
-    // Vérifier la taille du PDF
+    // Check PDF size
-    const maxSize = parseInt(process.env.PDF_MAX_SIZE) || 10485760; // 10MB par défaut
+    const maxSize = parseInt(process.env.PDF_MAX_SIZE) || 10485760; // 10MB default
    if (pdfBuffer.length > maxSize) {
      return res.status(413).json({
        success: false,
-        error: 'Le PDF généré dépasse la taille maximale autorisée'
+        error: 'Generated PDF exceeds maximum allowed size'
      });
    }
-    // Envoyer le PDF
+    // Send PDF
    res.setHeader('Content-Type', 'application/pdf');
    res.setHeader('Content-Disposition', `attachment; filename="${sanitizeFilename(title)}.pdf"`);
    res.setHeader('Content-Length', pdfBuffer.length);
@ -91,7 +91,7 @@ router.post('/pdf', async (req, res) => {
    res.send(pdfBuffer);
  } catch (error) {
-    console.error('Erreur génération PDF:', error);
+    console.error('PDF generation error:', error);
    if (browser) {
      await browser.close();
@ -99,12 +99,12 @@ router.post('/pdf', async (req, res) => {
    res.status(500).json({
      success: false,
-      error: 'Erreur lors de la génération du PDF'
+      error: 'Error during PDF generation'
    });
  }
 });
-// Fonction utilitaire pour échapper le HTML
+// Utility function to escape HTML
 function escapeHtml(text) {
  const map = {
    '&': '&amp;',
@ -116,30 +116,30 @@ function escapeHtml(text) {
  return text.replace(/[&<>"']/g, function(m) { return map[m]; });
 }
-// Fonction pour convertir le markdown en HTML stylé avec support Mermaid
+// Function to convert markdown to styled HTML with Mermaid support
 function generateStyledHTML(content, title) {
  let html = content;
-  // Traitement des diagrammes Mermaid AVANT les blocs de code
+  // Process Mermaid diagrams BEFORE code blocks
  html = html.replace(/```mermaid\n([\s\S]*?)```/g, '<div class="mermaid">$1</div>');
-  // Traitement des blocs de code avec langage
+  // Process code blocks with language
  html = html.replace(/```(\w+)?\n([\s\S]*?)```/g, (match, lang, code) => {
    const language = lang ? ` class="language-${lang}"` : '';
    return `<pre><code${language}>${escapeHtml(code)}</code></pre>`;
  });
-  // Code en ligne
+  // Inline code
  html = html.replace(/`([^`]+)`/g, '<code>$1</code>');
-  // Traitement des tableaux amélioré
+  // Enhanced table processing
  html = html.replace(/(\|.*\|\s*\n)+/g, (match) => {
    const lines = match.trim().split('\n').filter(line => line.trim());
    let tableHtml = '<table>\n';
    let inHeader = true;
    lines.forEach((line, index) => {
-      // Ignorer les lignes de séparation
+      // Ignore separator lines
      if (line.match(/^\s*\|[\s\-:]*\|\s*$/)) {
        inHeader = false;
        return;
@ -165,35 +165,35 @@ function generateStyledHTML(content, title) {
    return tableHtml;
  });
-  // Conversion markdown vers HTML
+  // Markdown to HTML conversion
  html = html
-    // Titres (en ordre décroissant)
+    // Headings (in descending order)
    .replace(/^#{6}\s+(.*$)/gm, '<h6>$1</h6>')
    .replace(/^#{5}\s+(.*$)/gm, '<h5>$1</h5>')
    .replace(/^#{4}\s+(.*$)/gm, '<h4>$1</h4>')
    .replace(/^#{3}\s+(.*$)/gm, '<h3>$1</h3>')
    .replace(/^#{2}\s+(.*$)/gm, '<h2>$1</h2>')
    .replace(/^#{1}\s+(.*$)/gm, '<h1>$1</h1>')
-    // Citations
+    // Blockquotes
    .replace(/^>\s+(.*$)/gm, '<blockquote>$1</blockquote>')
-    // Gras et italique (ordre important)
+    // Bold and italic (order matters)
    .replace(/\*\*\*(.*?)\*\*\*/g, '<strong><em>$1</em></strong>')
    .replace(/\*\*(.*?)\*\*/g, '<strong>$1</strong>')
    .replace(/\*(.*?)\*/g, '<em>$1</em>')
-    // Barré
+    // Strikethrough
    .replace(/~~(.*?)~~/g, '<del>$1</del>')
-    // Listes numérotées
+    // Numbered lists
    .replace(/^(\s*)(\d+)\. (.*$)/gm, '<li class="numbered">$3</li>')
-    // Listes à puces et tâches
+    // Bullet lists and tasks
-    .replace(/^(\s*)- \[x\] (.*$)/gm, '<li class="todo-done">✅ $2</li>')
+    .replace(/^(\s*)- \[x\] (.*$)/gm, '<li class="todo-done">$2</li>')
-    .replace(/^(\s*)- \[ \] (.*$)/gm, '<li class="todo">☐ $2</li>')
+    .replace(/^(\s*)- \[ \] (.*$)/gm, '<li class="todo">$2</li>')
    .replace(/^(\s*)[*\-+] (.*$)/gm, '<li>$2</li>')
-    // Liens
+    // Links
    .replace(/\[([^\]]+)\]\(([^\)]+)\)/g, '<a href="$2" target="_blank">$1</a>')
-    // Ligne horizontale
+    // Horizontal rule
    .replace(/^---+$/gm, '<hr>');
-  // Grouper les listes consécutives
+  // Group consecutive lists
  html = html.replace(/(<li[^>]*>.*?<\/li>\s*)+/gs, (match) => {
    if (match.includes('class="numbered"')) {
      return '<ol>' + match.replace(/ class="numbered"/g, '') + '</ol>';
@ -202,21 +202,21 @@ function generateStyledHTML(content, title) {
    }
  });
-  // Nettoyer les listes multiples consécutives
+  // Clean up consecutive multiple lists
  html = html.replace(/(<\/[uo]l>\s*<[uo]l>)/g, '');
-  // Grouper les citations consécutives
+  // Group consecutive blockquotes
  html = html.replace(/(<blockquote>.*?<\/blockquote>\s*)+/gs, (match) => {
    const content = match.replace(/<\/?blockquote>/g, '');
    return '<blockquote>' + content + '</blockquote>';
  });
-  // Traiter les paragraphes
+  // Process paragraphs
  html = html.split('\n\n').map(paragraph => {
    paragraph = paragraph.trim();
    if (!paragraph) return '';
-    // Ne pas entourer les éléments de bloc dans des paragraphes
+    // Don't wrap block elements in paragraphs
    if (paragraph.match(/^<(h[1-6]|div|table|ul|ol|blockquote|hr|pre)/)) {
      return paragraph;
    }
@ -226,7 +226,7 @@ function generateStyledHTML(content, title) {
  const styledHTML = `
 <!DOCTYPE html>
-<html lang="fr">
+<html lang="en">
 <head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
@ -272,7 +272,7 @@ function generateStyledHTML(content, title) {
      word-wrap: break-word;
    }
-    /* Titres style GitHub */
+    /* GitHub-style headings */
    h1 {
      color: #24292f;
      font-size: 2em;
@ -317,14 +317,14 @@ function generateStyledHTML(content, title) {
      page-break-after: avoid;
    }
-    /* Paragraphes */
+    /* Paragraphs */
    p {
      margin: 0 0 12pt 0;
      orphans: 2;
      widows: 2;
    }
-    /* Listes */
+    /* Lists */
    ul, ol {
      margin: 0 0 12pt 0;
      padding-left: 2em;
@ -343,7 +343,7 @@ function generateStyledHTML(content, title) {
      line-height: 1.5;
    }
-    /* Tâches */
+    /* Tasks */
    li.todo {
      list-style: none;
      margin-left: -2em;
@ -357,7 +357,7 @@ function generateStyledHTML(content, title) {
      color: #656d76;
    }
-    /* Mise en forme du texte */
+    /* Text formatting */
    strong {
      font-weight: 600;
    }
@ -371,7 +371,7 @@ function generateStyledHTML(content, title) {
      color: #656d76;
    }
-    /* Liens */
+    /* Links */
    a {
      color: #0969da;
      text-decoration: none;
@ -381,7 +381,7 @@ function generateStyledHTML(content, title) {
      text-decoration: underline;
    }
-    /* Citations */
+    /* Blockquotes */
    blockquote {
      margin: 12pt 0;
      padding: 0 12pt;
@ -397,7 +397,7 @@ function generateStyledHTML(content, title) {
      margin-bottom: 0;
    }
-    /* Ligne horizontale */
+    /* Horizontal rule */
    hr {
      margin: 24pt 0;
      border: none;
@ -405,7 +405,7 @@ function generateStyledHTML(content, title) {
      height: 0;
    }
-    /* Tableaux style GitHub */
+    /* GitHub-style tables */
    table {
      border-collapse: collapse;
      width: 100%;
@ -429,7 +429,7 @@ function generateStyledHTML(content, title) {
      background-color: #f6f8fa;
    }
-    /* Code style GitHub */
+    /* GitHub-style code */
    code {
      font-family: 'SFMono-Regular', Consolas, 'Liberation Mono', Menlo, monospace;
      background-color: rgba(175, 184, 193, 0.2);
@ -457,7 +457,7 @@ function generateStyledHTML(content, title) {
      font-size: inherit;
    }
-    /* Diagrammes Mermaid */
+    /* Mermaid diagrams */
    .mermaid {
      text-align: center;
      margin: 16pt 0;
@ -469,7 +469,7 @@ function generateStyledHTML(content, title) {
      height: auto;
    }
-    /* Éviter les coupures de page */
+    /* Avoid page breaks */
    h1, h2, h3, h4, h5, h6 {
      page-break-after: avoid;
    }
@ -484,7 +484,7 @@ function generateStyledHTML(content, title) {
      page-break-inside: avoid;
    }
-    /* Améliorer la lisibilité */
+    /* Improve readability */
    body {
      -webkit-font-smoothing: antialiased;
      -moz-osx-font-smoothing: grayscale;
@ -500,13 +500,13 @@ function generateStyledHTML(content, title) {
  return styledHTML;
 }
-// Fonction pour nettoyer le nom de fichier
+// Function to sanitize filename
 function sanitizeFilename(filename) {
  return filename
-    .replace(/[^\w\s-]/g, '') // Supprimer caractères spéciaux
+    .replace(/[^\w\s-]/g, '') // Remove special characters
-    .replace(/\s+/g, '-') // Remplacer espaces par tirets
+    .replace(/\s+/g, '-') // Replace spaces with dashes
-    .toLowerCase() // Minuscules
+    .toLowerCase() // Lowercase
-    .substring(0, 100); // Limiter la longueur
+    .substring(0, 100); // Limit length
 }
 module.exports = router;
--- a/routes/index.js
+++ b/routes/index.js
@ -2,22 +2,22 @@ const express = require('express');
 const router = express.Router();
 const { getPage } = require('../views/page');
-// Route principale
+// Main route
 router.get('/', (req, res) => {
  res.send(getPage());
 });
-// Route à propos
+// About route
 router.get('/about', (req, res) => {
  const { getHeader } = require('../views/header');
  const { getFooter } = require('../views/footer');
  res.send(`
 <!DOCTYPE html>
-<html lang="fr">
+<html lang="en">
 <head>
  <meta charset="UTF-8">
-  <title>À propos - Journal de Conception</title>
+  <title>About - Design Journal</title>
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <link rel="stylesheet" href="/assets/css/style.css">
 </head>
@ -26,47 +26,35 @@ router.get('/about', (req, res) => {
  <main style="display: block; max-width: 800px; margin: 0 auto; padding: 2rem;">
    <section>
-      <h2>À propos de l'application</h2>
+      <h2>About the Application</h2>
      <div style="padding: 2rem;">
        <p>
-          Cette application aide les équipes à réaliser un suivi structuré et collaboratif de la conception de leurs projets. Elle permet d'archiver les étapes clés, d'assurer la traçabilité des décisions, et de simplifier la coordination.
+          This application helps teams maintain structured and collaborative tracking of their design projects. It allows archiving key steps, ensuring traceability of decisions, and simplifying coordination.
        </p>
      </div>
    </section>
    <section style="margin-top: 2rem;">
-      <h2>Historique</h2>
+      <h2>History</h2>
      <div style="padding: 2rem;">
        <p>
-          Ce projet est né du besoin de centraliser et d'organiser les notes de conception lors du développement de projets techniques. Il offre un environnement intuitif pour documenter les décisions architecturales et suivre l'évolution des projets.
+          This project was born from the need to centralize and organize design notes during the development of technical projects. It offers an intuitive environment for documenting architectural decisions and tracking project evolution.
        </p>
      </div>
    </section>
    <section style="margin-top: 2rem;">
-      <h2>Équipe</h2>
+      <h2>Open Source</h2>
      <div style="padding: 2rem;">
        <ul style="list-style: none; padding: 0;">
          <li style="padding: 0.5rem 0; border-bottom: 1px solid var(--border-color);">
            <strong>Augustin ROUX</strong> – Développeur et Concepteur principal
          </li>
        </ul>
      </div>
    </section>
    <section style="margin-top: 2rem;">
      <h2>Contact</h2>
      <div style="padding: 2rem;">
        <p>
-          <strong>Email :</strong> <a href="mailto:augustin.j.l.roux@gmail.com" style="color: var(--secondary-color);">augustin.j.l.roux@gmail.com</a><br><br>
+          This project is open source and available under the MIT License. Contributions are welcome!
          <strong>Dépôt Git :</strong> <a href="https://gitea.legion-muyue.fr/Muyue/conception-assistant" target="_blank" style="color: var(--secondary-color);">https://gitea.legion-muyue.fr/Muyue/conception-assistant</a>
        </p>
      </div>
    </section>
    <div style="text-align: center; margin: 3rem 0 2rem 0;">
      <a href="/" style="background: var(--secondary-color); color: white; padding: 0.8rem 2rem; text-decoration: none; border-radius: 25px; display: inline-block; transition: all 0.3s ease;">
-        ← Retour à l'application
+        Back to Application
      </a>
    </div>
  </main>
--- a/routes/templates.js
+++ b/routes/templates.js
@ -3,17 +3,15 @@ const router = express.Router();
 const fs = require('fs');
 const path = require('path');
-// GET /api/templates/:domain/:level - Récupérer un template spécifique
+// GET /api/templates/default - Get the default template
-router.get('/:domain/:level', (req, res) => {
+router.get('/default', (req, res) => {
  const { domain, level } = req.params;
  try {
-    const templatePath = path.join(__dirname, '../templates', domain, `${level}.md`);
+    const templatePath = path.join(__dirname, '../templates/default.md');
    if (!fs.existsSync(templatePath)) {
      return res.status(404).json({
        success: false,
-        error: `Template non trouvé : ${domain}/${level}`
+        error: 'Default template not found'
      });
    }
@ -22,94 +20,14 @@ router.get('/:domain/:level', (req, res) => {
    res.json({
      success: true,
      data: {
        domain,
        level,
        content: templateContent
      }
    });
  } catch (error) {
-    console.error('Erreur lors de la lecture du template:', error);
+    console.error('Error reading template:', error);
    res.status(500).json({
      success: false,
-      error: 'Erreur serveur lors de la lecture du template'
+      error: 'Server error while reading template'
    });
  }
 });
 // GET /api/templates/:domain - Lister les niveaux disponibles pour un domaine
 router.get('/:domain', (req, res) => {
  const { domain } = req.params;
  try {
    const domainPath = path.join(__dirname, '../templates', domain);
    if (!fs.existsSync(domainPath)) {
      return res.status(404).json({
        success: false,
        error: `Domaine non trouvé : ${domain}`
      });
    }
    const files = fs.readdirSync(domainPath);
    const levels = files
      .filter(file => file.endsWith('.md'))
      .map(file => file.replace('.md', ''));
    res.json({
      success: true,
      data: {
        domain,
        levels
      }
    });
  } catch (error) {
    console.error('Erreur lors de la lecture du domaine:', error);
    res.status(500).json({
      success: false,
      error: 'Erreur serveur lors de la lecture du domaine'
    });
  }
 });
 // GET /api/templates - Lister tous les domaines disponibles
 router.get('/', (req, res) => {
  try {
    const templatesPath = path.join(__dirname, '../templates');
    if (!fs.existsSync(templatesPath)) {
      return res.json({
        success: true,
        data: []
      });
    }
    const domains = fs.readdirSync(templatesPath, { withFileTypes: true })
      .filter(dirent => dirent.isDirectory())
      .map(dirent => dirent.name);
    // Pour chaque domaine, récupérer les niveaux disponibles
    const domainsWithLevels = domains.map(domain => {
      const domainPath = path.join(templatesPath, domain);
      const files = fs.readdirSync(domainPath);
      const levels = files
        .filter(file => file.endsWith('.md'))
        .map(file => file.replace('.md', ''));
      return {
        domain,
        levels
      };
    });
    res.json({
      success: true,
      data: domainsWithLevels
    });
  } catch (error) {
    console.error('Erreur lors de la lecture des templates:', error);
    res.status(500).json({
      success: false,
      error: 'Erreur serveur lors de la lecture des templates'
    });
  }
 });
--- a/templates/business/complet.md
+++ b/templates/business/complet.md
@ -1,304 +0,0 @@
 # Journal de Conception - Projet Business (Complet)
 ## 1. Introduction
 **Présentation du contexte business :**
 [Décrire l'écosystème marché, les méga-tendances, les disruptions sectorielles et l'opportunité business identifiée]
 **Idée principale du projet :**
 [Résumer la vision entrepreneuriale, le business model innovant et la stratégie de création de valeur]
 **Positionnement concurrentiel :**
 [Situer l'entreprise dans son environnement compétitif, identifier les avantages distinctifs et la stratégie de différenciation]
 ## 2. Objectifs du projet
 **Objectifs principaux :**
 - [ ] **Objectif de croissance** : [CA visé, expansion géographique, parts de marché]
 - [ ] **Objectif de rentabilité** : [Marges, ROI, cash flow positif]
 - [ ] **Objectif stratégique** : [Leadership marché, innovation, sustainability]
 **Vision et mission :**
 - **Vision 2030** : [Ambition long terme, impact sociétal]
 - **Mission** : [Raison d'être, valeurs fondamentales]
 - **Purpose** : [Impact positif, contribution écosystème]
 **OKR (Objectives and Key Results) :**
 ### Objectif 1 : Conquête marché
 - **KR1** : Atteindre [X]% de part de marché en [timeframe]
 - **KR2** : Acquérir [Y] clients enterprise en [période]
 - **KR3** : Expansion dans [Z] nouveaux pays
 ### Objectif 2 : Excellence opérationnelle
 - **KR1** : NPS > 70 et churn < 5%
 - **KR2** : Marge opérationnelle > 25%
 - **KR3** : Time-to-market < 6 mois
 ## 3. Organisation du document
 Ce journal suit la méthodologie Lean Startup étendue :
 - **Sections 1-4** : Strategic foundation (vision, marché, value prop)
 - **Sections 5-6** : Business model innovation (monétisation, opérations)
 - **Sections 7-8** : Go-to-market & scaling (acquisition, retention)
 - **Sections 9-10** : Growth & optimization (KPI, amélioration continue)
 ## 4. Présentation et spécifications du projet
 **Description stratégique détaillée :**
 [Expliquer l'opportunité business, la stratégie concurrentielle et la création de valeur différenciante]
 ### 4.1 Analyse marché approfondie
 **Sizing et segmentation :**
 - **TAM (Total Addressable Market)** : [Taille globale du marché]
 - **SAM (Serviceable Addressable Market)** : [Marché adressable]
 - **SOM (Serviceable Obtainable Market)** : [Marché atteignable]
 **Segments clients prioritaires :**
 1. **Segment primaire** : [Demographics, psychographics, comportements]
   - Taille : [Volume, valeur]
   - Croissance : [CAGR, drivers]
   - Accessibilité : [Canaux, coût d'acquisition]
 2. **Segment secondaire** : [Caractéristiques distinctes]
 3. **Segments futurs** : [Expansion roadmap]
 **Analyse concurrentielle 360° :**
 | Concurrent | Forces | Faiblesses | Part marché | Stratégie |
 |------------|--------|------------|-------------|-----------|
 | Leader 1   | [Assets] | [Gaps] | X% | [Approach] |
 | Challenger 2| [Strengths] | [Limits] | Y% | [Strategy] |
 ### 4.2 Proposition de valeur unique
 **Value Proposition Canvas :**
 ```
 ┌─────────────────────────┬─────────────────────────┐
 │     Customer Profile     │     Value Map           │
 ├─────────────────────────┼─────────────────────────┤
 │ Jobs-to-be-done:        │ Products & Services:    │
 │ • [Job 1]               │ • [Product 1]           │
 │ • [Job 2]               │ • [Service 1]           │
 │                         │                         │
 │ Pains:                  │ Pain Relievers:         │
 │ • [Pain 1]              │ • [Relief 1]            │
 │ • [Pain 2]              │ • [Relief 2]            │
 │                         │                         │
 │ Gains:                  │ Gain Creators:          │
 │ • [Gain 1]              │ • [Creator 1]           │
 │ • [Gain 2]              │ • [Creator 2]           │
 └─────────────────────────┴─────────────────────────┘
 ```
 ## 5. Fonctionnalités attendues
 ### 5.1 Business Model Innovation
 - [ ] **Revenue Streams** : Diversification et optimisation sources revenus
 - [ ] **Pricing Strategy** : Modèles tarifaires value-based, dynamic
 - [ ] **Cost Structure** : Optimisation coûts, economies échelle
 - [ ] **Unit Economics** : LTV/CAC positif et scaling
 ### 5.2 Customer Experience Excellence
 - [ ] **Customer Journey** : Parcours optimisé multi-touchpoints
 - [ ] **CRM & Automation** : Personalisation à l'échelle
 - [ ] **Customer Success** : Réduction churn, expansion accounts
 - [ ] **Feedback Loops** : Voice of customer, amélioration continue
 ### 5.3 Opérations & Scaling
 - [ ] **Process Excellence** : Standardisation, automation, quality
 - [ ] **Supply Chain** : Resilience, sustainability, cost optimization
 - [ ] **Technology Platform** : Scalable architecture, data-driven
 - [ ] **People & Culture** : Talent acquisition, development, retention
 ### 5.4 Innovation & R&D
 - [ ] **Product Innovation** : Roadmap, features différenciantes
 - [ ] **Technology Innovation** : IP development, tech partnerships
 - [ ] **Business Model Innovation** : Nouveaux segments, channels
 - [ ] **Open Innovation** : Ecosystème partenaires, M&A
 ## 6. Conception globale
 **Business Architecture :**
 ```
 Strategy → Business Model → Operating Model → Execution → Performance
 ```
 **Ecosystem Design :**
 - **Core Business** : Activités principales génératrices valeur
 - **Platform Layer** : Infrastructure partagée, APIs, data
 - **Partner Network** : Alliances stratégiques, intégrations
 - **Innovation Layer** : R&D, ventures, emerging technologies
 ### 6.1 Operating Model
 **Organizational Design :**
 - **Structure** : [Functional/Divisional/Matrix/Network]
 - **Governance** : [Decision rights, accountability, controls]
 - **Capabilities** : [Core competencies, differentiators]
 **Process Architecture :**
 - **Core Processes** : [Value creation, delivery, support]
 - **Management Processes** : [Planning, monitoring, improvement]
 - **Enabling Processes** : [HR, IT, Finance, Legal]
 ## 7. Problématiques identifiées et solutions envisagées
 | Challenge Business | Strategic Solutions |
 |--------------------|-------------------|
 | Product-Market Fit | Lean validation, customer co-creation |
 | Scaling Challenges | Process automation, talent development |
 | Competitive Pressure | Differentiation, innovation, partnerships |
 | Capital Requirements | Fundraising strategy, capital efficiency |
 ### 7.1 Risk Assessment & Mitigation
 **Risques stratégiques :**
 - **Market Risk** : [Demand volatility, substitution threats]
 - **Competitive Risk** : [New entrants, price wars]
 - **Operational Risk** : [Scaling issues, key person dependency]
 - **Financial Risk** : [Cash flow, funding availability]
 **Risk Mitigation Strategies :**
 - Diversification (markets, products, revenue streams)
 - Strategic partnerships and alliances
 - Agile operating model and fast pivoting
 - Strong cash management and financial controls
 ## 8. Environnement et outils de travail
 **Business Intelligence Stack :**
 - **Analytics** : Tableau, Power BI, Looker
 - **CRM** : Salesforce, HubSpot avec custom integrations
 - **ERP** : SAP, Oracle, custom solutions
 - **Financial Planning** : Adaptive Planning, Anaplan
 **Growth & Marketing Technology :**
 - **Marketing Automation** : Marketo, Pardot, Eloqua
 - **Customer Data Platform** : Segment, Tealium
 - **A/B Testing** : Optimizely, VWO
 - **Attribution** : Multi-touch attribution platforms
 **Operational Excellence Tools :**
 - **Process Management** : Nintex, K2, custom workflows
 - **Project Management** : Asana, Monday, enterprise tools
 - **Collaboration** : Slack, Microsoft Teams, custom apps
 - **Knowledge Management** : Confluence, Notion, SharePoint
 ## 9. Phases du projet et planification
 ### Phase 1 - Foundation & Validation (6 mois)
 **Mois 1-2 : Market Intelligence & Strategy**
 - [ ] Deep market research et competitive analysis
 - [ ] Business model design et validation hypothèses
 - [ ] Go-to-market strategy et channel optimization
 **Mois 3-4 : Product-Market Fit**
 - [ ] MVP development et customer validation
 - [ ] Pricing strategy et unit economics optimization
 - [ ] Early customer acquisition et feedback loops
 **Mois 5-6 : Operations Foundation**
 - [ ] Core team building et organizational design
 - [ ] Process documentation et quality systems
 - [ ] **Livrable** : Validated business model
 ### Phase 2 - Growth & Scaling (12 mois)
 **Mois 7-12 : Market Penetration**
 - [ ] Sales et marketing engine scaling
 - [ ] Customer success program implementation
 - [ ] Partnership ecosystem development
 **Mois 13-18 : Operational Excellence**
 - [ ] Process automation et efficiency gains
 - [ ] Technology platform et data infrastructure
 - [ ] International expansion preparation
 ### Phase 3 - Scale & Optimize (18 mois)
 **Mois 19-24 : Market Leadership**
 - [ ] Category creation et thought leadership
 - [ ] Advanced analytics et AI integration
 - [ ] M&A strategy et ecosystem expansion
 **Mois 25-36 : Sustainable Growth**
 - [ ] Innovation pipeline et R&D investment
 - [ ] ESG strategy et impact measurement
 - [ ] **Livrable** : Market leading position
 ## 10. Gestion de projet (Agile Business)
 **Governance Model :**
 - Board of Directors avec external expertise
 - Executive Committee pour décisions opérationnelles
 - Innovation Committee pour nouveaux développements
 - Risk Committee pour gestion risques
 **Performance Management :**
 - OKR cascade avec alignment stratégique
 - Balanced Scorecard multi-dimensionnel
 - Real-time dashboards et KPI monitoring
 - Regular business reviews et course correction
 **Agile Operating Principles :**
 - Fast decision making et lean processes
 - Customer-centric approach et feedback integration
 - Data-driven decisions et experimentation
 - Continuous learning et adaptation
 ## 11. Conclusion
 **Value Creation attendue :**
 [Résumer la création de valeur économique, sociale et environnementale]
 **Competitive Advantages :**
 [Avantages concurrentiels durables et barrières à l'entrée]
 **Long-term Vision :**
 - [ ] Market leadership dans segments clés
 - [ ] Platform business avec network effects
 - [ ] Innovation continue et differentiation
 - [ ] Positive impact et sustainability leadership
 **Exit Strategy Options :**
 - IPO timeline et readiness requirements
 - Strategic acquisition potentielle
 - Management buyout scenarios
 - Succession planning et continuity
 ## 12. Annexes
 ### Annexe A - Business Plan Détaillé
 **Financial Projections (5 ans) :**
 - P&L statements avec assumptions détaillées
 - Cash flow projections et funding requirements
 - Balance sheet projections et ratios analysis
 - Sensitivity analysis et scenario planning
 ### Annexe B - Market Research Data
 **Primary Research :**
 - Customer interviews et surveys data
 - Competitive intelligence et benchmarking
 - Industry expert interviews
 - Focus groups results
 **Secondary Research :**
 - Industry reports et market studies
 - Financial analysis competitors
 - Regulatory environment analysis
 - Technology trends assessment
 ### Annexe C - Operational Plans
 **Go-to-Market Plan :**
 - Channel strategy et partner program
 - Sales process et enablement tools
 - Marketing campaigns et budget allocation
 - Customer onboarding et success metrics
 **Technology Roadmap :**
 - Platform architecture et scalability
 - Integration requirements et API strategy
 - Data architecture et analytics capabilities
 - Security et compliance requirements
 ### Annexe D - Legal & Compliance
 **Corporate Structure :**
 - Entity formation et ownership structure
 - IP protection et licensing strategy
 - Regulatory compliance requirements
 - Risk management et insurance coverage
 ### Annexe E - Team & Organizational Design
 **Talent Strategy :**
 - Key roles et recruitment plan
 - Compensation et equity programs
 - Performance management system
 - Culture et values definition
 ---
 *Journal créé le : [DATE]*
 *Dernière mise à jour : [DATE]*
 *Funding Round : [Seed/Series A/B/C]*
 *Valuation : [Current valuation et trajectory]*
--- a/templates/business/detaille.md
+++ b/templates/business/detaille.md
@ -1,148 +0,0 @@
 # Journal de Conception - Projet Business (Détaillé)
 ## 1. Introduction
 **Présentation du contexte business :**
 [Décrire le marché, la concurrence, les opportunités identifiées et la problématique économique]
 **Idée principale du projet :**
 [Résumer le concept business, la proposition de valeur et l'innovation stratégique]
 ## 2. Objectifs du projet
 **Objectifs principaux :**
 - [ ] **Objectif financier** : [Chiffre d'affaires visé, ROI, rentabilité]
 - [ ] **Objectif marché** : [Part de marché, segments ciblés]
 - [ ] **Objectif stratégique** : [Positionnement, différenciation, avantage concurrentiel]
 **Fonctionnalités business clés recherchées :**
 - **Value Proposition** : Création de valeur unique pour les clients
 - **Revenue Model** : Modèle de monétisation et flux de revenus
 - **Market Strategy** : Approche de mise sur le marché
 - **Operations** : Processus métier et optimisation opérationnelle
 ## 3. Organisation du document
 Ce journal suit la méthodologie Lean Business Canvas :
 - **Sections 1-4** : Vision et analyse marché (fondations stratégiques)
 - **Sections 5-6** : Modèle économique et opérations (cœur business)
 - **Sections 7-8** : Mise sur le marché et validation (execution)
 - **Sections 9-10** : Mesure et optimisation (performance business)
 ## 4. Présentation et spécifications du projet
 **Description détaillée :**
 [Expliquer le concept business, ses enjeux économiques et son contexte de marché]
 **Cahier des charges business :**
 - **Problème identifié** : [Pain points clients, besoins non satisfaits]
 - **Solution proposée** : [Produit/service, mécanisme de résolution]
 - **Marché cible** : [Segmentation, personas, taille de marché]
 **Business Model Canvas :**
 ```
 ┌─────────────────┬─────────────────┬─────────────────┬─────────────────┬─────────────────┐
 │ Partenaires     │ Activités clés  │ Proposition de  │ Relations       │ Segments de     │
 │ clés            │                 │ valeur          │ clients         │ clientèle       │
 │                 ├─────────────────┤                 ├─────────────────┤                 │
 │                 │ Ressources      │                 │ Canaux de       │                 │
 │                 │ clés            │                 │ distribution    │                 │
 ├─────────────────┴─────────────────┴─────────────────┼─────────────────┴─────────────────┤
 │ Structure des coûts                                  │ Sources de revenus                │
 └──────────────────────────────────────────────────────┴───────────────────────────────────┘
 ```
 ## 5. Fonctionnalités attendues
 - [ ] **Analyse de marché** : Étude concurrentielle, sizing, opportunités
 - [ ] **Développement produit** : MVP, itérations, product-market fit
 - [ ] **Stratégie commerciale** : Pricing, go-to-market, channels
 - [ ] **Opérations business** : Processus, KPI, optimisation coûts
 - [ ] **Gestion financière** : Business plan, projections, fundraising
 ## 6. Conception globale
 **Chaîne de valeur business :**
 ```
 Identification besoin → Développement solution → Mise sur marché → Génération revenus → Optimisation
 ```
 **Architecture business :**
 - **Couche stratégique** : Vision, mission, objectifs long terme
 - **Couche opérationnelle** : Processus, ressources, partenariats
 - **Couche commerciale** : Marketing, ventes, relation client
 - **Couche financière** : Modèle économique, contrôle de gestion
 ## 7. Problématiques identifiées et solutions envisagées
 | Problématique business | Solutions envisagées |
 |------------------------|---------------------|
 | Validation product-market fit | Lean startup, MVP, tests A/B |
 | Acquisition clients | Marketing digital, partenariats, referrals |
 | Scalabilité business | Automatisation, standardisation processus |
 | Compétitivité prix | Optimisation coûts, différenciation valeur |
 ## 8. Environnement et outils de travail
 **Outils d'analyse business :**
 - **Stratégie** : SWOT, Porter, BCG Matrix
 - **Finance** : Excel, Google Sheets, QuickBooks
 - **CRM** : Salesforce, HubSpot, Pipedrive
 - **Analytics** : Google Analytics, Mixpanel, Tableau
 **Frameworks business :**
 - Lean Canvas pour modélisation rapide
 - Design Thinking pour innovation
 - OKR pour pilotage objectifs
 - Balanced Scorecard pour performance
 ## 9. Phases du projet et planification
 **Phase 1 - Discovery & Validation (6 semaines) :**
 - [ ] Étude de marché approfondie
 - [ ] Validation hypothèses business
 - [ ] Développement MVP
 **Phase 2 - Go-to-Market (8 semaines) :**
 - [ ] Stratégie commerciale et pricing
 - [ ] Lancement marketing et acquisition
 - [ ] Mesure product-market fit
 **Phase 3 - Scale & Optimize (12 semaines) :**
 - [ ] Optimisation processus commerciaux
 - [ ] Expansion marché et segments
 - [ ] Amélioration rentabilité
 **Phase 4 - Growth & Expansion (ongoing) :**
 - [ ] Développement nouveaux produits/services
 - [ ] Expansion géographique ou segments
 - [ ] Partenariats stratégiques
 ## 10. Gestion de projet (approche Agile Business)
 **Méthode itérative :**
 - Build → Measure → Learn cycles
 - Pivots basés sur données marché
 - Validation continue hypothèses business
 **KPI et métriques de suivi :**
 - Customer Acquisition Cost (CAC)
 - Lifetime Value (LTV)
 - Monthly Recurring Revenue (MRR)
 - Churn rate et retention
 ## 11. Conclusion
 **Contributions business attendues :**
 [Résumer l'impact économique, l'innovation marché et la création de valeur]
 **Opportunités de croissance :**
 [Marchés adjacents, évolutions possibles du business model]
 **Perspectives d'expansion :**
 - [ ] Extension gamme produits/services
 - [ ] Nouveaux segments de clientèle
 - [ ] Partenariats stratégiques et alliances
 ## 12. Annexes
 **Business Plan détaillé :**
 [Plan financier sur 3-5 ans avec hypothèses]
 **Études de marché :**
 [Analyses concurrentielles, interviews clients, sizing]
 **Projections financières :**
 [P&L prévisionnel, cash flow, bilans projetés]
 ---
 *Journal créé le : [DATE]*
 *Dernière mise à jour : [DATE]*
--- a/templates/business/simple.md
+++ b/templates/business/simple.md
@ -1,94 +0,0 @@
 # Journal de Conception - Projet Business
 ## 1. Introduction
 **Contexte du projet :**
 [Décrire brièvement l'opportunité business à saisir]
 **Idée principale :**
 [Résumer le concept business et la proposition de valeur en une phrase]
 ## 2. Objectifs du projet
 **Objectifs principaux :**
 - [ ] Objectif financier
 - [ ] Objectif marché
 - [ ] Objectif stratégique
 **Fonctionnalités business clés :**
 - Proposition de valeur unique
 - Modèle de revenus
 - Stratégie d'acquisition clients
 ## 3. Présentation et spécifications
 **Description détaillée :**
 [Expliquer le concept business et ses enjeux économiques]
 **Cahier des charges :**
 - **Marché cible** : [Segmentation clients]
 - **Problème résolu** : [Pain points adressés]
 - **Solution proposée** : [Produit/service développé]
 ## 4. Fonctionnalités attendues
 - [ ] **Analyse marché** : Étude concurrentielle et positionnement
 - [ ] **Business model** : Monétisation et sources de revenus
 - [ ] **Go-to-market** : Stratégie commerciale et marketing
 - [ ] **Opérations** : Processus métier et delivery
 ## 5. Conception globale
 **Business model :**
 ```
 Problème client → Solution → Valeur → Monétisation → Croissance
 ```
 **Architecture business :**
 - **Segments clients** : Personas et besoins
 - **Canaux** : Distribution et acquisition
 - **Revenus** : Modèle de pricing
 - **Partenariats** : Écosystème et alliances
 ## 6. Problématiques et solutions
 | Défi business | Solution envisagée |
 |---------------|-------------------|
 | Product-market fit | Validation lean, MVP |
 | Acquisition clients | Marketing digital, SEO |
 | Compétitivité | Différenciation, innovation |
 ## 7. Environnement et outils
 **Outils business :**
 - Analyse : Excel, Google Analytics
 - CRM : HubSpot, Pipedrive
 - Marketing : Mailchimp, réseaux sociaux
 - Finance : QuickBooks, Stripe
 **Ressources clés :**
 - Équipe et compétences
 - Financement initial
 - Partenaires stratégiques
 ## 8. Phases du projet
 **Phase 1 - Validation (2 mois) :**
 - [ ] Étude de marché
 - [ ] MVP et premiers clients
 - [ ] Validation business model
 **Phase 2 - Lancement (4 mois) :**
 - [ ] Développement produit
 - [ ] Stratégie marketing
 - [ ] Première croissance
 **Phase 3 - Croissance (6 mois) :**
 - [ ] Scale opérations
 - [ ] Expansion marché
 - [ ] Optimisation rentabilité
 ## 9. Conclusion
 **État d'avancement :**
 [À compléter au fur et à mesure]
 **Prochaines étapes :**
 - [ ] Validation concept auprès du marché
 - [ ] Développement MVP
 - [ ] Première campagne acquisition
 ---
 *Journal créé le : [DATE]*
 *Dernière mise à jour : [DATE]*
--- a/templates/default.md
+++ b/templates/default.md
@ -0,0 +1,104 @@
 # Design Journal - Project Title
 ## 1. Introduction
 **Project Context:**
 [Briefly describe the problem to solve]
 **Main Idea:**
 [Summarize the envisioned solution in one sentence]
 ## 2. Project Objectives
 **Main Objectives:**
 - [ ] Objective 1
 - [ ] Objective 2
 - [ ] Objective 3
 **Key Features:**
 - Essential feature 1
 - Essential feature 2
 ## 3. Presentation and Specifications
 **Detailed Description:**
 [Explain what the project does and its stakes]
 **Requirements:**
 - **General Need**: [Problem to solve]
 - **Specific Needs**: [List of requirements]
 ## 4. Expected Functionality
 - [ ] **User Module**: Registration, login, profile
 - [ ] **Main Module**: [Core project functionality]
 - [ ] **Admin Module**: Data management
 - [ ] **Security Module**: Authentication, authorization
 ## 5. Overall Design
 **User View:**
 ```
 Web Interface → Authentication → Dashboard → Functional Modules
 ```
 **Technical Architecture:**
 ```
 [Client] ↔ [REST API] ↔ [Business Logic] ↔ [Database]
 ```
 **Software Architecture:**
 - **Frontend**: React/Vue.js + CSS Framework
 - **Backend**: Node.js/Python + Web Framework
 - **Database**: PostgreSQL/MongoDB
 - **API**: REST or GraphQL
 ## 6. Problems and Solutions
 | Problem | Technical Solution |
 |---------|-------------------|
 | Performance | Redis cache + query optimization |
 | Security | HTTPS + JWT + input validation |
 | Scalability | Microservices architecture |
 ## 7. Environment and Tools
 **Development Tools:**
 - IDE: VS Code / IntelliJ
 - Versioning: Git + GitHub/GitLab
 - Project Management: Jira / Trello
 **Tech Stack:**
 - Runtime: Node.js / Python
 - Framework: Express / Django
 - Tests: Jest / Pytest
 ## 8. Project Phases
 **Phase 1 - Design (2 weeks):**
 - [ ] Finalize architecture
 - [ ] Interface mockups
 - [ ] Setup development environment
 **Phase 2 - Development (6 weeks):**
 - [ ] Backend and API
 - [ ] Frontend and interfaces
 - [ ] Continuous integration
 **Phase 3 - Testing and Deployment (2 weeks):**
 - [ ] Automated tests
 - [ ] Production deployment
 - [ ] User documentation
 ## 9. Conclusion
 **Progress Status:**
 [To be completed as you go]
 **Next Steps:**
 - [ ] Priority step 1
 - [ ] Priority step 2
 ---
 *Journal created on: [DATE]*
 *Last updated: [DATE]*
--- a/templates/design/complet.md
+++ b/templates/design/complet.md
@ -1,319 +0,0 @@
 # Journal de Conception - Projet Design (Complet)
 ## 1. Introduction
 **Présentation du contexte design :**
 [Décrire l'écosystème créatif, les tendances design émergentes, les défis d'expérience utilisateur et l'opportunité d'innovation créative]
 **Idée principale du projet :**
 [Résumer la vision créative, l'approche design thinking et la stratégie d'expérience différenciante]
 **Positionnement dans l'écosystème créatif :**
 [Situer le projet par rapport aux standards industry, identifier les innovations design et les références inspirantes]
 ## 2. Objectifs du projet
 **Objectifs principaux :**
 - [ ] **Objectif créatif** : [Innovation visuelle, signature esthétique, impact émotionnel]
 - [ ] **Objectif expérientiel** : [Parcours utilisateur optimal, engagement, satisfaction]
 - [ ] **Objectif business** : [Conversion, adoption, différenciation concurrentielle]
 **Design Vision & Principles :**
 - **Vision** : [Aspiration créative long terme, impact utilisateurs]
 - **Principles** : [Valeurs design guidant les décisions créatives]
  - Principe 1 : [ex: Human-centered design]
  - Principe 2 : [ex: Inclusive accessibility]
  - Principe 3 : [ex: Sustainable design practices]
 **Creative Objectives & Key Results (OKR) :**
 ### Objectif 1 : Excellence créative
 - **KR1** : Design System adoption > 95% across products
 - **KR2** : User satisfaction score > 8.5/10
 - **KR3** : Industry recognition awards [X nominations/wins]
 ### Objectif 2 : User Experience Excellence
 - **KR1** : Task completion rate > 90%
 - **KR2** : Time to value < 3 minutes
 - **KR3** : Accessibility WCAG AAA compliance
 ## 3. Organisation du document
 Ce journal suit la méthode Design Thinking augmentée :
 - **Sections 1-4** : Discovery & Empathy (user research, insights)
 - **Sections 5-6** : Ideation & Concept (creative solutions, prototyping)
 - **Sections 7-8** : Design & Validation (implementation, testing)
 - **Sections 9-10** : Scale & Evolution (system design, continuous improvement)
 ## 4. Présentation et spécifications du projet
 **Description créative détaillée :**
 [Expliquer le projet design, ses enjeux d'expérience et son contexte d'innovation créative]
 ### 4.1 User Research & Insights
 **User Personas Détaillées :**
 **Persona 1 : [Nom persona primaire]**
 - **Demographics** : [Âge, profession, localisation]
 - **Psychographics** : [Valeurs, motivations, lifestyle]
 - **Goals** : [Objectifs fonctionnels et émotionnels]
 - **Pain Points** : [Frustrations, obstacles, besoins non satisfaits]
 - **Technology Comfort** : [Niveau expertise, devices utilisés]
 - **Quote** : "[Phrase représentative du persona]"
 **Journey Mapping :**
 ```
 Awareness → Consideration → Trial → Onboarding → Usage → Mastery → Advocacy
    ↓           ↓          ↓         ↓           ↓        ↓         ↓
 [Emotions]  [Touch]    [Pain]    [Joy]       [Habit]  [Flow]   [Share]
 ```
 **Research Methodology :**
 - **Quantitative** : Analytics, surveys, A/B testing
 - **Qualitative** : Interviews, observation, co-creation
 - **Mixed Methods** : Card sorting, tree testing, diary studies
 - **Continuous** : Voice of customer, support feedback, NPS
 ### 4.2 Design Strategy & Direction
 **Creative Direction :**
 - **Aesthetic Philosophy** : [Modernism/Minimalism/Maximalism/etc.]
 - **Emotional Tone** : [Professional/Friendly/Luxurious/Approachable]
 - **Visual Language** : [Clean/Bold/Organic/Geometric]
 - **Brand Personality** : [Innovative/Trustworthy/Playful/Sophisticated]
 **Competitive Design Analysis :**
 | Competitor | Design Strengths | Opportunities | Differentiation |
 |------------|-----------------|---------------|----------------|
 | Leader 1   | [Visual impact] | [UX gaps]     | [Our advantage]|
 | Challenger 2| [Innovation]    | [Complexity]  | [Our approach] |
 ## 5. Fonctionnalités attendues
 ### 5.1 Design System & Standards
 - [ ] **Design Tokens** : Couleurs, typography, spacing, shadows systématiques
 - [ ] **Component Library** : Atomic design avec variations et states
 - [ ] **Pattern Library** : Templates, layouts, common interactions
 - [ ] **Guidelines** : Usage, accessibility, brand consistency
 ### 5.2 User Experience Design
 - [ ] **Information Architecture** : Structure logique, navigation intuitive
 - [ ] **Interaction Design** : Micro-interactions, transitions, feedback
 - [ ] **Responsive Design** : Multi-device, adaptive layouts
 - [ ] **Accessibility** : WCAG compliance, inclusive design practices
 ### 5.3 Visual Design Excellence
 - [ ] **Visual Hierarchy** : Typography scales, color systems
 - [ ] **Iconography** : Cohérent icon set, illustration style
 - [ ] **Photography** : Style guide, image treatment
 - [ ] **Motion Design** : Animations purposeful, brand coherent
 ### 5.4 Prototyping & Validation
 - [ ] **Rapid Prototyping** : Low-fi to high-fi progression
 - [ ] **Interactive Prototypes** : Clickable demos, user flows
 - [ ] **Usability Testing** : Moderated/unmoderated sessions
 - [ ] **A/B Testing** : Design variations, performance metrics
 ## 6. Conception globale
 **Design Process Framework :**
 ```
 Discover → Define → Ideate → Prototype → Test → Implement → Measure → Iterate
 ```
 **Design System Architecture :**
 - **Foundation Layer** : Design tokens, brand guidelines
 - **Component Layer** : Reusable UI components, patterns
 - **Application Layer** : Templates, page layouts, flows
 - **Documentation Layer** : Usage guidelines, code examples
 ### 6.1 Creative Methodology
 **Ideation Techniques :**
 - **Divergent Thinking** : Brainstorming, mind mapping, SCAMPER
 - **Convergent Thinking** : Dot voting, impact/effort matrix
 - **Co-creation** : Design workshops, user collaboration
 - **Inspiration** : Mood boards, style tiles, precedent analysis
 **Design Critique Framework :**
 - **Objective Assessment** : Usability heuristics, guidelines compliance
 - **Subjective Evaluation** : Aesthetic appeal, emotional response
 - **User Validation** : Testing feedback, behavioral data
 - **Business Impact** : Conversion metrics, engagement analytics
 ## 7. Problématiques identifiées et solutions envisagées
 | Design Challenge | Creative Solutions |
 |------------------|-------------------|
 | Multi-platform consistency | Design system with shared tokens |
 | Accessibility at scale | Inclusive design process, automated testing |
 | Performance vs visual richness | Progressive loading, optimized assets |
 | Localization & cultural adaptation | Flexible layouts, cultural research |
 ### 7.1 Technical Design Constraints
 **Performance Considerations :**
 - Image optimization et progressive loading
 - CSS efficiency et bundle size
 - Animation performance et 60fps target
 - Mobile-first responsive approach
 **Accessibility Requirements :**
 - WCAG 2.1 AAA compliance strategy
 - Screen reader compatibility
 - Keyboard navigation support
 - Color contrast et visual indicators
 ## 8. Environnement et outils de travail
 **Design Tool Ecosystem :**
 - **Primary Design** : Figma avec plugins spécialisés
 - **Prototyping** : Figma, Principle, ProtoPie pour interactions avancées
 - **Collaboration** : FigJam, Miro pour workshops créatifs
 - **Handoff** : Figma Dev Mode, Zeplin pour développeurs
 **Creative Assets Management :**
 - **DAM System** : Centralized asset library
 - **Version Control** : Git for design files, abstract workflows
 - **Stock Resources** : Unsplash, Pexels, custom photography
 - **Icon Libraries** : Custom set + Phosphor/Heroicons backup
 **Testing & Analytics Tools :**
 - **Usability Testing** : Maze, UserTesting, Hotjar sessions
 - **Analytics** : Google Analytics, Mixpanel, Amplitude
 - **Heatmaps** : Hotjar, Crazy Egg, Microsoft Clarity
 - **Performance** : Lighthouse, WebPageTest, Core Web Vitals
 ## 9. Phases du projet et planification
 ### Phase 1 - Discovery & Foundation (8 semaines)
 **Semaines 1-2 : Research & Insights**
 - [ ] User research comprehensive (interviews, surveys, analytics)
 - [ ] Competitive analysis et benchmark créatif
 - [ ] Stakeholder interviews et business requirements
 **Semaines 3-4 : Strategy & Direction**
 - [ ] Creative direction workshops et mood boards
 - [ ] Information architecture et site mapping
 - [ ] Design principles et guidelines foundation
 **Semaines 5-6 : Concept Development**
 - [ ] Initial wireframes et user flows
 - [ ] Style exploration et visual directions
 - [ ] **Livrable** : Design strategy document
 **Semaines 7-8 : Foundation Systems**
 - [ ] Design tokens et color systems
 - [ ] Typography scale et component foundations
 - [ ] **Livrable** : Design system starter kit
 ### Phase 2 - Design & Prototyping (12 semaines)
 **Semaines 9-12 : Core Component Design**
 - [ ] Atomic components library development
 - [ ] Pattern documentation et usage guidelines
 - [ ] Accessibility testing et compliance validation
 **Semaines 13-16 : Application Design**
 - [ ] Key screens et template designs
 - [ ] Interactive prototypes avec realistic content
 - [ ] Cross-device responsive validation
 **Semaines 17-20 : Testing & Iteration**
 - [ ] Usability testing sessions (moderated + unmoderated)
 - [ ] A/B testing setup pour key decisions
 - [ ] Design refinements basés sur feedback users
 - [ ] **Livrable** : Validated design system
 ### Phase 3 - Implementation & Launch (10 semaines)
 **Semaines 21-24 : Development Collaboration**
 - [ ] Developer handoff avec specifications détaillées
 - [ ] QA design review et pixel-perfect validation
 - [ ] Performance optimization et asset preparation
 **Semaines 25-28 : Launch Preparation**
 - [ ] Staging environment design review
 - [ ] User acceptance testing et final adjustments
 - [ ] Launch communication et training materials
 **Semaines 29-30 : Go-Live & Monitoring**
 - [ ] Launch execution avec design monitoring
 - [ ] User feedback collection et analytics setup
 - [ ] **Livrable** : Live product with analytics dashboard
 ### Phase 4 - Optimization & Evolution (6 semaines)
 **Semaines 31-33 : Performance Analysis**
 - [ ] User behavior analysis et heatmap review
 - [ ] Conversion funnel optimization
 - [ ] Accessibility audit complet
 **Semaines 34-36 : Continuous Improvement**
 - [ ] Design system evolution et new components
 - [ ] Feature enhancement basé sur user feedback
 - [ ] **Livrable** : Optimized experience + roadmap
 ## 10. Gestion de projet (Design Operations)
 **Design Team Structure :**
 - **Design Lead** : Vision créative, strategy, stakeholder management
 - **UX Designers** : Research, wireframing, user flows
 - **UI Designers** : Visual design, component creation
 - **Design System Manager** : Consistency, documentation, adoption
 **Collaboration Framework :**
 - **Design Reviews** : Structured critique sessions
 - **Cross-functional Workshops** : Product, Engineering, Business alignment
 - **User Research Cadence** : Regular testing et insights sharing
 - **Design Sprint Methodology** : Rapid problem-solving cycles
 **Quality Assurance Process :**
 - **Design QA Checklist** : Consistency, accessibility, performance
 - **User Testing Pipeline** : Continuous validation workflow
 - **Metrics Tracking** : Design KPIs et business impact measurement
 - **Design Debt Management** : Systematic improvement backlog
 ## 11. Conclusion
 **Creative Impact attendu :**
 [Résumer l'innovation visuelle, l'amélioration d'expérience et l'impact business]
 **Design System Legacy :**
 [Scalabilité future, adoption organisation, influence industry]
 **Évolution créative :**
 - [ ] Design language maturity et sophistication
 - [ ] New interaction paradigms exploration
 - [ ] Emerging technology integration (AR/VR/AI)
 - [ ] Accessibility leadership et inclusive design
 **Thought Leadership Opportunities :**
 - [ ] Design conference presentations
 - [ ] Case study publications
 - [ ] Open source design system contributions
 - [ ] Industry awards et recognition
 ## 12. Annexes
 ### Annexe A - Design System Documentation
 **Component Specifications :**
 - Complete component library avec all states
 - Usage guidelines et do's/don'ts
 - Code snippets et implementation examples
 - Accessibility specifications for each component
 ### Annexe B - User Research Data
 **Research Artifacts :**
 - Interview transcripts et insights synthesis
 - Survey results avec statistical analysis
 - Usability testing videos et findings reports
 - Analytics data avec behavior insights
 ### Annexe C - Visual Assets
 **Creative Deliverables :**
 - High-fidelity mockups pour all key screens
 - Interactive prototype files (Figma/Principle)
 - Asset export package pour development
 - Brand guideline document complet
 ### Annexe D - Performance & Accessibility Reports
 **Technical Validation :**
 - Lighthouse performance audits
 - WCAG compliance detailed checklist
 - Cross-browser compatibility testing results
 - Mobile device testing comprehensive report
 ### Annexe E - Future Roadmap
 **Design Evolution Plan :**
 - Next version features et improvements
 - Emerging technology integration roadmap
 - Design system scaling strategy
 - Team growth et capability development plan
 ---
 *Journal créé le : [DATE]*
 *Dernière mise à jour : [DATE]*
 *Design System Version : [v1.0]*
 *User Testing Participants : [Total number]]*
--- a/templates/design/detaille.md
+++ b/templates/design/detaille.md
@ -1,154 +0,0 @@
 # Journal de Conception - Projet Design (Détaillé)
 ## 1. Introduction
 **Présentation du contexte design :**
 [Décrire le brief créatif, les enjeux esthétiques et fonctionnels, la problématique d'usage]
 **Idée principale du projet :**
 [Résumer le concept créatif, l'approche design et l'innovation visuelle/UX]
 ## 2. Objectifs du projet
 **Objectifs principaux :**
 - [ ] **Objectif esthétique** : [Style visuel, identité graphique, impact émotionnel]
 - [ ] **Objectif fonctionnel** : [Usabilité, ergonomie, accessibilité]
 - [ ] **Objectif expérientiel** : [Parcours utilisateur, engagement, satisfaction]
 **Fonctionnalités design clés recherchées :**
 - **Visual Identity** : Charte graphique, cohérence visuelle
 - **User Experience** : Parcours utilisateur optimisé
 - **Interface Design** : Interfaces intuitives et attractives
 - **Interaction Design** : Micro-interactions et animations
 ## 3. Organisation du document
 Ce journal suit la méthode Design Thinking :
 - **Sections 1-4** : Empathie et définition (compréhension utilisateur)
 - **Sections 5-6** : Idéation et prototypage (création solutions)
 - **Sections 7-8** : Test et itération (validation design)
 - **Sections 9-10** : Implémentation et mesure (design opérationnel)
 ## 4. Présentation et spécifications du projet
 **Description détaillée :**
 [Expliquer le projet design, ses enjeux créatifs et son contexte d'utilisation]
 **Cahier des charges design :**
 - **Brief créatif** : [Objectifs, contraintes, public cible]
 - **Contraintes techniques** : [Supports, formats, technologies]
 - **Guidelines** : [Charte graphique, accessibilité, responsive]
 **Design System Framework :**
 ```
 ┌─────────────────────────────────────────────────────────────┐
 │                    DESIGN TOKENS                            │
 │  Colors • Typography • Spacing • Shadows • Borders         │
 ├─────────────────────────────────────────────────────────────┤
 │                    COMPONENTS                               │
 │  Atoms • Molecules • Organisms • Templates • Pages         │
 ├─────────────────────────────────────────────────────────────┤
 │                    PATTERNS & GUIDELINES                    │
 │  Navigation • Forms • Data • Feedback • Content            │
 └─────────────────────────────────────────────────────────────┘
 ```
 ## 5. Fonctionnalités attendues
 - [ ] **Research & Discovery** : User research, personas, journey mapping
 - [ ] **Visual Design** : Moodboards, style guides, assets visuels
 - [ ] **Prototype & Test** : Wireframes, maquettes, tests utilisateurs
 - [ ] **Design System** : Composants réutilisables, documentation
 - [ ] **Handoff Development** : Specifications, assets optimisés
 ## 6. Conception globale
 **Processus de design :**
 ```
 Research → Ideation → Design → Prototype → Test → Iterate → Deliver
 ```
 **Architecture du design :**
 - **Couche utilisateur** : Personas, besoins, contextes d'usage
 - **Couche expérience** : User flows, wireframes, architecture information
 - **Couche interface** : UI components, interactions, micro-animations
 - **Couche système** : Design tokens, guidelines, documentation
 ## 7. Problématiques identifiées et solutions envisagées
 | Problématique design | Solutions envisagées |
 |---------------------|---------------------|
 | Cohérence visuelle multi-supports | Design system unifié, tokens partagés |
 | Accessibilité et inclusion | WCAG guidelines, tests accessibilité |
 | Performance et optimisation | Assets optimisés, lazy loading, compression |
 | Maintenance et évolutivité | Composants modulaires, documentation vivante |
 ## 8. Environnement et outils de travail
 **Outils de design :**
 - **UI/UX Design** : Figma, Adobe XD, Sketch
 - **Prototypage** : InVision, Principle, Framer
 - **Collaboration** : Figma, Miro, FigJam
 - **Handoff** : Zeplin, Avocode, Figma Dev Mode
 **Ressources créatives :**
 - **Inspiration** : Dribbble, Behance, Awwwards
 - **Assets** : Unsplash, Pexels, Iconify
 - **Fonts** : Google Fonts, Adobe Fonts, Fontshare
 - **Couleurs** : Coolors, Adobe Color, Paletton
 ## 9. Phases du projet et planification
 **Phase 1 - Discovery & Research (3 semaines) :**
 - [ ] Audit design existant
 - [ ] User research et personas
 - [ ] Benchmark concurrentiel
 **Phase 2 - Idéation & Concept (4 semaines) :**
 - [ ] Moodboards et directions créatives
 - [ ] Wireframes et architecture information
 - [ ] Premiers prototypes basse fidélité
 **Phase 3 - Design & Prototype (6 semaines) :**
 - [ ] Design system et composants
 - [ ] Maquettes haute fidélité
 - [ ] Prototypes interactifs
 **Phase 4 - Test & Iterate (3 semaines) :**
 - [ ] Tests utilisateurs
 - [ ] Itérations basées feedback
 - [ ] Validation design final
 **Phase 5 - Production & Handoff (2 semaines) :**
 - [ ] Assets production
 - [ ] Documentation développeur
 - [ ] Suivi implémentation
 ## 10. Gestion de projet (Design Ops)
 **Approche collaborative :**
 - Co-création avec utilisateurs finaux
 - Reviews régulières avec stakeholders
 - Workshops d'idéation en équipe
 **Métriques design :**
 - Task Success Rate
 - Time on Task
 - System Usability Scale (SUS)
 - Net Promoter Score (NPS)
 ## 11. Conclusion
 **Contributions design attendues :**
 [Résumer l'impact visuel, l'amélioration UX et l'innovation créative]
 **Applications design :**
 [Déclinaisons possibles, supports additionnels]
 **Perspectives d'évolution :**
 - [ ] Évolutions saisonnières et thématiques
 - [ ] Adaptation nouveaux supports/devices
 - [ ] Enrichissement interactions et animations
 ## 12. Annexes
 **Style Guide complet :**
 [Charte graphique détaillée avec examples d'usage]
 **User Research Data :**
 [Interviews, surveys, analytics, heatmaps]
 **Design System Documentation :**
 [Composants, guidelines, code snippets]
 ---
 *Journal créé le : [DATE]*
 *Dernière mise à jour : [DATE]*
--- a/templates/design/simple.md
+++ b/templates/design/simple.md
@ -1,94 +0,0 @@
 # Journal de Conception - Projet Design
 ## 1. Introduction
 **Contexte du projet :**
 [Décrire brièvement le brief créatif et les enjeux design]
 **Idée principale :**
 [Résumer le concept créatif et la direction artistique en une phrase]
 ## 2. Objectifs du projet
 **Objectifs principaux :**
 - [ ] Objectif esthétique
 - [ ] Objectif fonctionnel
 - [ ] Objectif utilisateur
 **Fonctionnalités design clés :**
 - Identité visuelle cohérente
 - Expérience utilisateur optimisée
 - Communication efficace
 ## 3. Présentation et spécifications
 **Description détaillée :**
 [Expliquer le projet design et ses enjeux créatifs]
 **Cahier des charges :**
 - **Public cible** : [Demographics et personas]
 - **Message** : [Communication à transmettre]
 - **Contraintes** : [Budget, délais, techniques]
 ## 4. Fonctionnalités attendues
 - [ ] **Recherche créative** : Moodboards, inspirations, tendances
 - [ ] **Concept visuel** : Direction artistique et style guide
 - [ ] **Création graphique** : Éléments visuels et déclinaisons
 - [ ] **Tests utilisateurs** : Validation et ajustements
 ## 5. Conception globale
 **Processus créatif :**
 ```
 Brief → Recherche → Concept → Création → Validation → Livraison
 ```
 **Éléments de design :**
 - **Couleurs** : Palette principale et secondaire
 - **Typographie** : Hiérarchie et lisibilité
 - **Iconographie** : Style et cohérence
 - **Layout** : Structure et équilibre
 ## 6. Problématiques et solutions
 | Défi créatif | Solution envisagée |
 |--------------|-------------------|
 | Cohérence multi-supports | Système de design unifié |
 | Lisibilité et accessibilité | Tests et guidelines WCAG |
 | Impact visuel | Couleurs et typography forte |
 ## 7. Environnement et outils
 **Outils créatifs :**
 - Design : Adobe Creative Suite, Figma
 - Prototypage : InVision, Principle
 - Collaboration : Figma, Miro
 - Présentation : Keynote, PowerPoint
 **Ressources :**
 - Banques d'images : Unsplash, Adobe Stock
 - Fonts : Google Fonts, Adobe Fonts
 - Inspiration : Dribbble, Behance
 ## 8. Phases du projet
 **Phase 1 - Recherche (1 semaine) :**
 - [ ] Analyse brief et concurrence
 - [ ] Moodboard et inspirations
 - [ ] Première direction créative
 **Phase 2 - Création (3 semaines) :**
 - [ ] Développement concept
 - [ ] Éléments graphiques
 - [ ] Déclinaisons principales
 **Phase 3 - Finalisation (1 semaine) :**
 - [ ] Ajustements client
 - [ ] Préparation livrables
 - [ ] Guide de style
 ## 9. Conclusion
 **État d'avancement :**
 [À compléter au fur et à mesure]
 **Prochaines étapes :**
 - [ ] Validation concept créatif
 - [ ] Production éléments graphiques
 - [ ] Livraison finale client
 ---
 *Journal créé le : [DATE]*
 *Dernière mise à jour : [DATE]*
--- a/templates/informatique/complet.md
+++ b/templates/informatique/complet.md
@ -1,162 +0,0 @@
 # Journal de Conception - Projet Informatique (Complet)
 ## 1. Introduction
 **Présentation du contexte informatique :**
 [Décrire l'environnement technologique, les systèmes existants, les défis techniques et la problématique informatique à résoudre]
 **Idée principale du projet :**
 [Résumer la solution technique envisagée, l'architecture proposée et l'innovation technologique]
 ## 2. Objectifs du projet
 **Objectifs principaux :**
 - [ ] **Objectif technique** : [Performance, scalabilité, maintainabilité visée]
 - [ ] **Objectif fonctionnel** : [Fonctionnalités clés à développer]
 - [ ] **Objectif qualité** : [Standards de code, sécurité, tests]
 **Fonctionnalités clés recherchées :**
 - **Module core** : Fonctionnalité centrale du système
 - **Module utilisateur** : Gestion des comptes et profils
 - **Module administration** : Back-office et supervision
 - **Module intégration** : APIs et connecteurs externes
 ## 3. Organisation du document
 Ce journal suit une approche itérative où chaque section évolue avec l'avancement du projet :
 - **Sections 1-4** : Vision et spécifications (évoluent peu)
 - **Sections 5-6** : Conception technique (ajustements fréquents)
 - **Sections 7-8** : Développement et déploiement (mises à jour continues)
 - **Sections 9-10** : Résultats et optimisation (analyse continue)
 ## 4. Présentation et spécifications du projet
 **Description détaillée :**
 [Expliquer le projet informatique, ses enjeux techniques et son contexte d'utilisation]
 **Cahier des charges technique :**
 - **Exigences fonctionnelles** : [Fonctionnalités attendues, cas d'usage]
 - **Exigences non-fonctionnelles** : [Performance, sécurité, disponibilité]
 - **Contraintes techniques** : [Technologies imposées, compatibilité]
 **Diagrammes et modélisation :**
 ```
 Architecture générale :
 [Client] ↔ [Load Balancer] ↔ [API Gateway] ↔ [Services] ↔ [Database]
 Flux de données :
 Input → Validation → Processing → Storage → Output
 ```
 ## 5. Fonctionnalités attendues
 - [ ] **Module utilisateur** : Authentification, autorisation, profils
 - [ ] **Module métier** : Fonctionnalités cœur du domaine
 - [ ] **Module administration** : Gestion système, configuration
 - [ ] **Module intégration** : APIs, webhooks, connecteurs
 - [ ] **Module reporting** : Tableaux de bord, analytics
 ## 6. Conception globale
 **Architecture système :**
 ```
 Client ↔ Load Balancer ↔ API Gateway ↔ Services ↔ Database
 ```
 **Architecture logicielle :**
 - **Frontend** : React/Vue.js avec state management
 - **Backend** : Node.js/Python avec architecture microservices
 - **Base de données** : PostgreSQL/MongoDB avec cache Redis
 - **Infrastructure** : Docker/Kubernetes sur cloud
 **Patterns de conception :**
 - Repository pattern pour l'accès aux données
 - CQRS pour la séparation lecture/écriture
 - Event sourcing pour l'historique
 - Clean Architecture pour l'indépendance
 ## 7. Problématiques identifiées et solutions envisagées
 | Problématique technique | Solutions envisagées |
 |------------------------|---------------------|
 | Scalabilité horizontale | Microservices + Load balancing |
 | Performance base de données | Cache Redis + optimisation requêtes |
 | Sécurité des données | Chiffrement + authentification forte |
 | Maintenance du code | Tests automatisés + CI/CD |
 ## 8. Environnement et outils de travail
 **Outils de développement :**
 - **IDE** : VS Code avec extensions spécialisées
 - **Versioning** : Git avec GitFlow
 - **Gestion projet** : Jira/Linear avec méthodologie Agile
 **Stack technique :**
 - **Runtime** : Node.js 18+ / Python 3.11+
 - **Frameworks** : Express/FastAPI + React/Next.js
 - **Base de données** : PostgreSQL + Redis
 - **Testing** : Jest/Pytest + Cypress/Playwright
 - **DevOps** : Docker + Kubernetes + GitHub Actions
 ## 9. Phases du projet et planification
 **Phase 1 - Architecture et fondations (4 semaines) :**
 - [ ] Setup environnement de développement
 - [ ] Architecture technique détaillée
 - [ ] CI/CD pipeline et infrastructure
 - [ ] **Livrable** : Environnement de développement opérationnel
 **Phase 2 - Développement MVP (8 semaines) :**
 - [ ] Implémentation modules core
 - [ ] Interface utilisateur de base
 - [ ] Tests unitaires et intégration
 - [ ] **Livrable** : Version MVP fonctionnelle
 **Phase 3 - Fonctionnalités avancées (6 semaines) :**
 - [ ] Modules spécialisés et intégrations
 - [ ] Optimisations performance
 - [ ] Tests de charge et sécurité
 - [ ] **Livrable** : Version complète
 **Phase 4 - Production et monitoring (2 semaines) :**
 - [ ] Déploiement production
 - [ ] Monitoring et alertes
 - [ ] Documentation utilisateur
 - [ ] **Livrable** : Système en production
 ## 10. Gestion de projet (méthode Agile)
 **Approche Scrum :**
 - Sprints de 2 semaines avec démonstrations
 - Daily standups et rétrospectives
 - Product backlog priorisé par valeur métier
 **Indicateurs de progression :**
 - Velocity de l'équipe (story points/sprint)
 - Code coverage et qualité (SonarQube)
 - Performance (temps de réponse, throughput)
 - Satisfaction utilisateur (NPS, feedback)
 ## 11. Conclusion
 **Contributions techniques attendues :**
 [Résumer l'innovation technique, l'amélioration des processus et l'impact organisationnel]
 **Architecture evolutive :**
 [Capacité d'adaptation, extensibilité future]
 **Perspectives d'amélioration :**
 - [ ] Intégration IA/ML pour l'automatisation
 - [ ] Extension mobile native
 - [ ] API publique pour écosystème partenaires
 - [ ] Migration vers architecture serverless
 ## 12. Annexes
 **Architecture détaillée :**
 [Diagrammes techniques, modèles de données, spécifications API]
 **Guide de déploiement :**
 [Procédures d'installation, configuration, maintenance]
 **Tests et validation :**
 [Stratégies de test, scénarios de validation, benchmarks]
 ---
 *Journal créé le : [DATE]*
 *Dernière mise à jour : [DATE]*
--- a/templates/informatique/detaille.md
+++ b/templates/informatique/detaille.md
@ -1,390 +0,0 @@
 # Journal de Conception - Projet Informatique (Détaillé)
 ## 1. Introduction
 **Présentation du contexte :**
 [Décrire le contexte métier, l'environnement et la problématique identifiée]
 **Idée principale du projet :**
 [Résumer la solution technique envisagée et son innovation]
 ## 2. Objectifs du projet
 **Objectifs principaux :**
 - [ ] **Objectif technique** : [Performance, sécurité, scalabilité visée]
 - [ ] **Objectif fonctionnel** : [Fonctionnalités clés à développer]
 - [ ] **Objectif utilisateur** : [Expérience et valeur apportée]
 **Fonctionnalités clés recherchées :**
 - **Module core** : [Fonctionnalité centrale du système]
 - **Module utilisateur** : [Gestion des comptes et profils]
 - **Module administration** : [Back-office et supervision]
 - **Module intégration** : [APIs et connecteurs externes]
 **Critères de réussite :**
 - Performance : Temps de réponse < 2s
 - Adoption : X utilisateurs actifs en Y mois
 - Qualité : Code coverage > 90%
 ## 3. Organisation du document
 Ce journal suit une approche itérative où chaque section évolue avec l'avancement du projet :
 - **Sections 1-4** : Vision et spécifications (évoluent peu)
 - **Sections 5-7** : Conception technique (ajustements fréquents)
 - **Sections 8-10** : Développement et déploiement (mises à jour continues)
 - **Section 11** : Retour d'expérience (enrichie régulièrement)
 ## 2. Analyse des besoins
 ### 2.1 Besoins fonctionnels
 #### RF-001 : [Nom du besoin]
 - **Description** :
 - **Acteur** :
 - **Priorité** : Haute/Moyenne/Basse
 - **Critères d'acceptation** :
 #### RF-002 : [Nom du besoin]
 - **Description** :
 - **Acteur** :
 - **Priorité** :
 - **Critères d'acceptation** :
 ### 2.2 Besoins non-fonctionnels
 #### Performance
 - Temps de réponse : < 2 secondes
 - Charge supportée : X utilisateurs simultanés
 - Disponibilité : 99.9%
 #### Sécurité
 - Authentification : OAuth 2.0
 - Autorisation : RBAC
 - Chiffrement : TLS 1.3
 #### Compatibilité
 - Navigateurs : Chrome, Firefox, Safari, Edge
 - Appareils : Desktop, Mobile, Tablette
 - OS : Windows, macOS, Linux
 ## 3. Architecture système
 ### 3.1 Architecture générale
 [Diagramme d'architecture global]
 ### 3.2 Stack technique
 #### Frontend
 - **Framework** : React 18 / Vue 3 / Angular 15
 - **État** : Redux / Pinia / NgRx
 - **UI** : Material-UI / Vuetify / Angular Material
 - **Build** : Vite / Webpack
 - **Tests** : Jest + Testing Library
 #### Backend
 - **Framework** : Node.js + Express / Python + FastAPI / Java + Spring
 - **API** : REST / GraphQL
 - **Authentification** : JWT / OAuth2
 - **Tests** : Jest / pytest / JUnit
 #### Base de données
 - **Principale** : PostgreSQL / MySQL / MongoDB
 - **Cache** : Redis
 - **Recherche** : Elasticsearch (si nécessaire)
 #### Infrastructure
 - **Cloud** : AWS / Azure / GCP
 - **Conteneurs** : Docker + Kubernetes
 - **CI/CD** : GitHub Actions / GitLab CI
 - **Monitoring** : Prometheus + Grafana
 ### 3.3 Modèle de données
 #### Entités principales
 ```sql
 -- Utilisateurs
 CREATE TABLE users (
  id SERIAL PRIMARY KEY,
  email VARCHAR(255) UNIQUE NOT NULL,
  password_hash VARCHAR(255) NOT NULL,
  role VARCHAR(50) DEFAULT 'user',
  created_at TIMESTAMP DEFAULT NOW(),
  updated_at TIMESTAMP DEFAULT NOW()
 );
 -- Contenu principal
 CREATE TABLE content (
  id SERIAL PRIMARY KEY,
  title VARCHAR(255) NOT NULL,
  description TEXT,
  user_id INTEGER REFERENCES users(id),
  status VARCHAR(50) DEFAULT 'draft',
  created_at TIMESTAMP DEFAULT NOW(),
  updated_at TIMESTAMP DEFAULT NOW()
 );
 ```
 #### Relations
 [Diagramme ERD]
 ## 4. Conception détaillée
 ### 4.1 Frontend - Composants
 #### Composant App
 ```jsx
 // Structure principale
 <App>
  <Router>
    <Header />
    <Sidebar />
    <MainContent />
    <Footer />
  </Router>
 </App>
 ```
 #### Composant Dashboard
 - **Props** : user, data
 - **State** : loading, filters
 - **Actions** : loadData, applyFilter
 ### 4.2 Backend - API
 #### Endpoints principaux
 ```
 GET    /api/users           - Liste des utilisateurs
 POST   /api/users           - Création utilisateur
 GET    /api/users/:id       - Détail utilisateur
 PUT    /api/users/:id       - Modification utilisateur
 DELETE /api/users/:id       - Suppression utilisateur
 GET    /api/content         - Liste du contenu
 POST   /api/content         - Création contenu
 GET    /api/content/:id     - Détail contenu
 PUT    /api/content/:id     - Modification contenu
 DELETE /api/content/:id     - Suppression contenu
 ```
 #### Middlewares
 - **Authentication** : Vérification JWT
 - **Authorization** : Vérification des rôles
 - **Rate limiting** : Limitation des appels
 - **Validation** : Validation des données
 - **Logging** : Journalisation des requêtes
 ### 4.3 Sécurité
 #### Authentification
 ```javascript
 // Flow OAuth2
 1. Redirection vers provider
 2. Callback avec code
 3. Exchange code -> token
 4. Stockage secure du token
 5. Utilisation avec Bearer header
 ```
 #### Gestion des erreurs
 ```javascript
 // Structure des erreurs
 {
  error: {
    code: 'USER_NOT_FOUND',
    message: 'Utilisateur introuvable',
    details: {},
    timestamp: '2025-01-01T12:00:00Z'
  }
 }
 ```
 ## 5. Planning détaillé
 ### Phase 1 : Setup et fondations (3 semaines)
 #### Semaine 1
 - [ ] Setup repository Git
 - [ ] Configuration environnements dev/staging/prod
 - [ ] Setup CI/CD pipeline
 - [ ] Configuration base de données
 - [ ] **Livrable** : Environnements opérationnels
 #### Semaine 2
 - [ ] Architecture frontend de base
 - [ ] Setup backend avec authentification
 - [ ] Intégration base de données
 - [ ] Tests unitaires de base
 - [ ] **Livrable** : Stack technique fonctionnelle
 #### Semaine 3
 - [ ] Interface utilisateur de base
 - [ ] API CRUD principale
 - [ ] Tests d'intégration
 - [ ] Documentation technique
 - [ ] **Livrable** : MVP fonctionnel
 ### Phase 2 : Développement core (4 semaines)
 #### Semaines 4-5
 - [ ] Implémentation des fonctionnalités principales
 - [ ] Interface utilisateur complète
 - [ ] Gestion des erreurs
 - [ ] **Livrable** : Version alpha
 #### Semaines 6-7
 - [ ] Fonctionnalités avancées
 - [ ] Optimisation des performances
 - [ ] Tests de charge
 - [ ] **Livrable** : Version beta
 ### Phase 3 : Finalisation (2 semaines)
 #### Semaine 8
 - [ ] Tests utilisateur
 - [ ] Corrections de bugs
 - [ ] Documentation utilisateur
 - [ ] Préparation déploiement production
 #### Semaine 9
 - [ ] Déploiement production
 - [ ] Monitoring et alertes
 - [ ] Formation utilisateurs
 - [ ] **Livrable** : Version 1.0
 ## 6. Tests et Qualité
 ### 6.1 Stratégie de tests
 - **Tests unitaires** : > 90% de couverture
 - **Tests d'intégration** : Tous les endpoints
 - **Tests end-to-end** : Parcours utilisateur critiques
 - **Tests de performance** : Charge nominale et pics
 ### 6.2 Outils de tests
 ```javascript
 // Frontend
 - Jest + Testing Library
 - Cypress pour E2E
 - Lighthouse pour performance
 // Backend
 - Jest / pytest
 - Supertest pour API
 - Artillery pour charge
 ```
 ### 6.3 Critères de qualité
 - **Code coverage** : > 90%
 - **Temps de build** : < 5 minutes
 - **Temps de déploiement** : < 10 minutes
 - **Performance** : Core Web Vitals > 90
 ## 7. Déploiement et Infrastructure
 ### 7.1 Environnements
 #### Développement
 - **URL** : http://localhost:3000
 - **Base** : PostgreSQL locale
 - **Données** : Jeu de test
 #### Staging
 - **URL** : https://staging.app.com
 - **Base** : PostgreSQL cloud
 - **Données** : Réplique anonymisée de prod
 #### Production
 - **URL** : https://app.com
 - **Base** : PostgreSQL cluster
 - **Données** : Données réelles
 ### 7.2 Architecture cloud
 ```yaml
 # Kubernetes deployment
 apiVersion: apps/v1
 kind: Deployment
 metadata:
  name: app-frontend
 spec:
  replicas: 3
  selector:
    matchLabels:
      app: frontend
  template:
    metadata:
      labels:
        app: frontend
    spec:
      containers:
      - name: frontend
        image: app/frontend:latest
        ports:
        - containerPort: 80
 ```
 ### 7.3 Monitoring
 - **Application** : Sentry pour erreurs
 - **Infrastructure** : Prometheus + Grafana
 - **Logs** : ELK Stack
 - **Uptime** : Pingdom / UptimeRobot
 ## 8. Maintenance et Evolution
 ### 8.1 Maintenance corrective
 - **Bugs critiques** : Correction < 4h
 - **Bugs majeurs** : Correction < 24h
 - **Bugs mineurs** : Correction < 1 semaine
 ### 8.2 Maintenance évolutive
 - **Mises à jour sécurité** : Mensuelle
 - **Nouvelles fonctionnalités** : Trimestrielle
 - **Refactoring** : Semestrielle
 ### 8.3 Roadmap
 #### V1.1 (3 mois)
 - [ ] Amélioration UX
 - [ ] API v2
 - [ ] Export de données
 #### V2.0 (6 mois)
 - [ ] Application mobile
 - [ ] Intelligence artificielle
 - [ ] Intégrations tierces
 ## 9. Documentation
 ### 9.1 Documentation technique
 - [ ] README détaillé
 - [ ] Guide de contribution
 - [ ] Documentation API (OpenAPI)
 - [ ] Architecture Decision Records (ADR)
 ### 9.2 Documentation utilisateur
 - [ ] Guide d'utilisation
 - [ ] FAQ
 - [ ] Tutoriels vidéo
 - [ ] Support en ligne
 ## 10. Risques et Mitigation
 | ID | Risque | Impact | Probabilité | Mitigation |
 |----|--------|---------|-------------|------------|
 | R1 | Retard de développement | Élevé | Moyenne | Buffer de temps, équipe élargie |
 | R2 | Problème de performance | Moyen | Faible | Tests de charge réguliers |
 | R3 | Faille de sécurité | Élevé | Faible | Audits sécurité, code review |
 | R4 | Indisponibilité cloud | Moyen | Faible | Multi-zone, backup automatique |
 ## 11. Journal de Développement
 ### [Date] - Setup initial
 [Notes sur la configuration initiale]
 ### [Date] - Développement Feature X
 [Défis rencontrés et solutions]
 ### [Date] - Tests et déploiement
 [Résultats des tests et déploiement]
 ## 12. Ressources et Références
 ### Ressources techniques
 - [Documentation React](https://reactjs.org/)
 - [Guide Node.js](https://nodejs.org/)
 - [Best practices sécurité](https://owasp.org/)
 ### Outils utilisés
 - [GitHub Repository](https://github.com/user/project)
 - [Projet Management](https://trello.com/board)
 - [Design System](https://figma.com/file)
--- a/templates/informatique/simple.md
+++ b/templates/informatique/simple.md
@ -1,95 +0,0 @@
 # Journal de Conception - Projet Informatique
 ## 1. Introduction
 **Contexte du projet :**
 [Décrire brièvement le problème à résoudre]
 **Idée principale :**
 [Résumer la solution envisagée en une phrase]
 ## 2. Objectifs du projet
 **Objectifs principaux :**
 - [ ] Objectif 1
 - [ ] Objectif 2
 - [ ] Objectif 3
 **Fonctionnalités clés recherchées :**
 - Fonctionnalité essentielle 1
 - Fonctionnalité essentielle 2
 ## 3. Présentation et spécifications
 **Description détaillée :**
 [Expliquer ce que fait le projet et ses enjeux]
 **Cahier des charges :**
 - **Besoin général** : [Problème à résoudre]
 - **Besoins spécifiques** : [Liste des exigences]
 ## 4. Fonctionnalités attendues
 - [ ] **Module utilisateur** : Inscription, connexion, profil
 - [ ] **Module principal** : [Fonctionnalité cœur du projet]
 - [ ] **Module administration** : Gestion des données
 - [ ] **Module sécurité** : Authentification, autorisation
 ## 5. Conception globale
 **Vue utilisateur :**
 ```
 Interface Web → Authentification → Dashboard → Modules fonctionnels
 ```
 **Architecture technique :**
 ```
 [Client] ↔ [API REST] ↔ [Logique métier] ↔ [Base de données]
 ```
 **Architecture logicielle :**
 - **Frontend** : React/Vue.js + CSS Framework
 - **Backend** : Node.js/Python + Framework web
 - **Base de données** : PostgreSQL/MongoDB
 - **API** : REST ou GraphQL
 ## 6. Problématiques et solutions
 | Problématique | Solution technique |
 |---------------|-------------------|
 | Performance | Cache Redis + optimisation requêtes |
 | Sécurité | HTTPS + JWT + validation inputs |
 | Scalabilité | Architecture microservices |
 ## 7. Environnement et outils
 **Outils de développement :**
 - IDE : VS Code / IntelliJ
 - Versioning : Git + GitHub/GitLab
 - Gestion projet : Jira / Trello
 **Stack technique :**
 - Runtime : Node.js / Python
 - Framework : Express / Django
 - Tests : Jest / Pytest
 ## 8. Phases du projet
 **Phase 1 - Conception (2 semaines) :**
 - [ ] Finaliser l'architecture
 - [ ] Mockups des interfaces
 - [ ] Setup environnement dev
 **Phase 2 - Développement (6 semaines) :**
 - [ ] Backend et API
 - [ ] Frontend et interfaces
 - [ ] Intégration continue
 **Phase 3 - Tests et déploiement (2 semaines) :**
 - [ ] Tests automatisés
 - [ ] Déploiement production
 - [ ] Documentation utilisateur
 ## 9. Conclusion
 **État d'avancement :**
 [À compléter au fur et à mesure]
 **Prochaines étapes :**
 - [ ] Étape prioritaire 1
 - [ ] Étape prioritaire 2
 ---
 *Journal créé le : [DATE]*
 *Dernière mise à jour : [DATE]*
--- a/templates/ingenierie/complet.md
+++ b/templates/ingenierie/complet.md
@ -1,301 +0,0 @@
 # Journal de Conception - Projet Ingénierie (Complet)
 ## 1. Introduction
 **Présentation du contexte d'ingénierie :**
 [Décrire l'écosystème industriel, les enjeux technologiques, les défis d'innovation et la problématique d'ingénierie complexe à résoudre]
 **Idée principale du projet :**
 [Résumer la vision technique, l'approche d'ingénierie système et l'innovation technologique disruptive]
 **Positionnement technologique :**
 [Situer le projet par rapport à l'état de l'art, identifier les ruptures technologiques et les avantages compétitifs]
 ## 2. Objectifs du projet
 **Objectifs principaux :**
 - [ ] **Objectif de performance** : [Breakthrough technique, records de performance]
 - [ ] **Objectif d'innovation** : [Propriété intellectuelle, différenciation technologique]
 - [ ] **Objectif industriel** : [Time-to-market, compétitivité, scalabilité]
 **Spécifications système critiques :**
 - **Performance** : Métriques quantifiées avec tolérances
 - **Fiabilité** : MTBF, disponibilité, maintenabilité
 - **Sécurité** : Analyses HAZOP, SIL, normes fonctionnelles
 - **Économie** : TCO, ROI, business case détaillé
 **Key Performance Indicators (KPI) :**
 ### KPI Techniques
 - **Efficacité** : > X% d'amélioration vs état de l'art
 - **Fiabilité** : MTBF > Y heures
 - **Sécurité** : SIL Z compliance
 ### KPI Business
 - **Time-to-Market** : Lancement < A mois
 - **Coût cible** : Réduction B% vs solution actuelle
 - **Parts de marché** : Capture C% en D années
 ## 3. Organisation du document
 Ce journal suit l'ingénierie système selon ISO 15288 :
 - **Sections 1-4** : Définition des besoins (stakeholder requirements)
 - **Sections 5-6** : Architecture système (system requirements & design)
 - **Sections 7-8** : Implémentation et intégration (realization & integration)
 - **Sections 9-10** : Validation et déploiement (verification & deployment)
 ## 4. Présentation et spécifications du projet
 **Description système complexe :**
 [Expliquer le système d'ingénierie, son environnement opérationnel, ses interactions et sa valeur ajoutée]
 ### 4.1 Analyse des besoins stakeholders
 **Parties prenantes :**
 - **Utilisateurs finaux** : Besoins opérationnels, contraintes d'usage
 - **Exploitants** : Maintenance, disponibilité, coûts d'exploitation
 - **Régulateurs** : Conformité normative, sécurité, environnement
 - **Investisseurs** : ROI, risques techniques, planning
 ### 4.2 Exigences système détaillées
 **Exigences fonctionnelles :**
 - **RF-001** : [Fonction principale avec critères quantifiés]
 - **RF-002** : [Fonction secondaire avec interfaces]
 - **RF-003** : [Fonction de sécurité avec redondance]
 **Exigences non-fonctionnelles :**
 - **Performance** : Débit, précision, temps de réponse
 - **Fiabilité** : Taux de panne, mode de défaillance
 - **Maintenabilité** : MTTR, accessibilité, diagnostics
 - **Sécurité** : Analyses des risques, barrières
 ### 4.3 Matrice de traçabilité
 ```
 Besoin → Exigence → Fonction → Solution → Test → Validation
  ↓        ↓         ↓         ↓       ↓        ↓
 [B1] → [REQ-001] → [F1] → [SOL-A] → [T1] → [V-OK]
 ```
 ## 5. Fonctionnalités attendues
 ### 5.1 Architecture fonctionnelle
 - [ ] **Analyse fonctionnelle** : FAST, SADT, diagrammes de cas d'usage
 - [ ] **Décomposition système** : PBS, WBS, interfaces définies
 - [ ] **Allocation exigences** : Répartition sur sous-systèmes
 - [ ] **Architecture logique** : Modèles comportementaux
 ### 5.2 Conception multi-disciplinaire
 - [ ] **Mécanique** : Dimensionnement, matériaux, assemblages
 - [ ] **Électronique** : Circuits, composants, compatibilité EMC
 - [ ] **Software** : Algorithmes, IHM, temps réel
 - [ ] **Automatique** : Régulation, supervision, diagnostic
 ### 5.3 Intégration et validation
 - [ ] **Intégration par étapes** : Sous-systèmes → Système complet
 - [ ] **Tests multi-niveaux** : Composants → Sous-systèmes → Système
 - [ ] **Validation environnementale** : Climatique, vibratoire, EMC
 - [ ] **Certification** : Conformité normes, marquage CE
 ## 6. Conception globale
 **Architecture système V-Model :**
 ```
 Besoins → Spécifications → Conception → Intégration → Validation → Exploitation
    ↑                                      ↓
 Définition ←————————————————————————————→ Vérification
 ```
 **Décomposition hiérarchique :**
 - **Niveau 1** : Système complet avec environnement
 - **Niveau 2** : Sous-systèmes principaux et interfaces
 - **Niveau 3** : Modules fonctionnels et composants
 - **Niveau 4** : Éléments de base et technologies
 ### 6.1 Choix technologiques critiques
 **Trade-off Analysis :**
 | Critère | Solution A | Solution B | Solution C | Décision |
 |---------|------------|------------|------------|----------|
 | Performance | ★★★ | ★★ | ★★★★ | Solution C |
 | Coût | ★★ | ★★★★ | ★★ | Compromis |
 | Fiabilité | ★★★★ | ★★ | ★★★ | Solution A |
 | Maturité | ★★★ | ★★★★ | ★★ | Solution B |
 ### 6.2 Architecture de sécurité
 **Analyse HAZOP :**
 - Identification des dangers et événements redoutés
 - Barrières de prévention et de protection
 - Architecture de sécurité avec redondance
 - Procédures d'urgence et de maintenance
 ## 7. Problématiques identifiées et solutions envisagées
 | Défi d'ingénierie complexe | Solutions système avancées |
 |----------------------------|----------------------------|
 | Couplage multiphysique | Co-simulation, modèles réduits |
 | Optimisation multi-objectifs | Algorithmes génétiques, Pareto |
 | Incertitudes et robustesse | Monte Carlo, Six Sigma |
 | Intégration hétérogène | Middleware, standards ouverts |
 ### 7.1 Gestion des risques techniques
 **Risk Management selon ISO 31000 :**
 - **Identification** : FMEA/FMECA, arbres de défaillance
 - **Évaluation** : Probabilité × Impact, matrices de risque
 - **Traitement** : Éviter, réduire, transférer, accepter
 - **Suivi** : KRI, revues périodiques, plan de contingence
 ### 7.2 Innovation et propriété intellectuelle
 **Stratégie IP :**
 - Veille technologique et analyse antériorités
 - Identification des innovations brevetables
 - Stratégie de dépôt et protection internationale
 - Valorisation et licensing des technologies
 ## 8. Environnement et outils de travail
 **Plateforme d'ingénierie intégrée :**
 - **PLM** : Siemens Teamcenter, Dassault 3DEXPERIENCE
 - **CAO/CAE** : CATIA, SolidWorks, Inventor avec simulation intégrée
 - **Simulation** : ANSYS Workbench, COMSOL Multiphysics
 - **Electronics** : Altium Designer, Cadence, ModelSim
 **Outils de validation :**
 - **Prototypage rapide** : Impression 3D métal, usinage 5 axes
 - **Instrumentation** : Acquisition haute fréquence, capteurs IoT
 - **Tests environnementaux** : Chambres climatiques, vibrateurs
 - **Certification** : Laboratoires accrédités, organismes notifiés
 **Infrastructure collaborative :**
 - **Gestion configuration** : Git pour code, PLM pour CAO
 - **Workflow** : Processus d'approbation automatisés
 - **Simulation cloud** : HPC pour calculs intensifs
 - **Digital twin** : Modèles connectés pour monitoring
 ## 9. Phases du projet et planification
 ### Phase 1 - Étude système (3 mois)
 **Mois 1 : Expression du besoin**
 - [ ] Analyse stakeholders et capture requirements
 - [ ] Étude de marché et positionnement concurrentiel
 - [ ] Faisabilité technique et économique préliminaire
 **Mois 2 : Architecture fonctionnelle**
 - [ ] Décomposition fonctionnelle et allocation exigences
 - [ ] Architecture logique et interfaces système
 - [ ] Analyses de risques et de sécurité initiales
 **Mois 3 : Choix technologiques**
 - [ ] Trade-off analysis et sélection technologies clés
 - [ ] Dimensionnement préliminaire et budget
 - [ ] **Livrable** : Dossier de définition système
 ### Phase 2 - Conception détaillée (6 mois)
 **Mois 4-5 : Conception sous-systèmes**
 - [ ] Spécifications détaillées par sous-système
 - [ ] Conception mécanique, électronique, software
 - [ ] Simulations multi-physiques et optimisation
 **Mois 6-7 : Intégration virtuelle**
 - [ ] Modèles système complets et co-simulation
 - [ ] Validation virtuelle et analyses robustesse
 - [ ] Plans de tests et procédures de validation
 **Mois 8-9 : Finalisation conception**
 - [ ] Optimisation performances et coûts
 - [ ] Documentation technique complète
 - [ ] **Livrable** : Dossier de conception détaillée
 ### Phase 3 - Réalisation et tests (8 mois)
 **Mois 10-12 : Prototypage**
 - [ ] Fabrication prototypes sous-systèmes
 - [ ] Tests unitaires et caractérisation
 - [ ] Corrections et optimisations
 **Mois 13-15 : Intégration système**
 - [ ] Assemblage et mise au point
 - [ ] Tests d'intégration et de performance
 - [ ] Validation environnementale
 **Mois 16-17 : Validation finale**
 - [ ] Tests de qualification complète
 - [ ] Certification et marquage réglementaire
 - [ ] **Livrable** : Système qualifié
 ### Phase 4 - Industrialisation (4 mois)
 **Mois 18-19 : Transfert production**
 - [ ] Ingénierie de production et outillages
 - [ ] Formation équipes et procédures
 - [ ] Pilote de production et optimisation
 **Mois 20-21 : Lancement commercial**
 - [ ] Production série et contrôle qualité
 - [ ] Support client et maintenance
 - [ ] **Livrable** : Produit industrialisé
 ## 10. Gestion de projet (Program Management)
 **Governance multi-projets :**
 - Program Manager avec steering committee
 - Work Package Leaders par discipline
 - Quality Manager et Risk Manager dédiés
 - Customer Interface et Certification Manager
 **Processus d'ingénierie :**
 - **Stage-Gate Process** : Jalons avec Go/No-Go
 - **Configuration Management** : Contrôle des changements
 - **Quality Assurance** : Audits et métriques qualité
 - **Knowledge Management** : Capitalisation et REX
 **Métriques de pilotage :**
 - **Planning** : % avancement vs plan, écarts délais
 - **Budget** : Coûts engagés vs budget, écarts
 - **Qualité** : Taux de non-conformité, actions correctives
 - **Risques** : Évolution scores risques, plans de mitigation
 ## 11. Conclusion
 **Breakthrough technologique attendu :**
 [Résumer l'innovation d'ingénierie, les performances révolutionnaires et l'impact industriel disruptif]
 **Competitive advantage durable :**
 [Barrières technologiques, propriété intellectuelle, écosystème]
 **Roadmap d'évolution :**
 - [ ] **Génération 2** : Améliorations incrémentales
 - [ ] **Plateforme produits** : Déclinaisons et variantes
 - [ ] **Technologies émergentes** : IA, quantique, bio-inspiré
 - [ ] **Écosystème partenaires** : Alliances et joint-ventures
 **Impact sociétal et environnemental :**
 - [ ] Contribution aux ODD (Objectifs Développement Durable)
 - [ ] Réduction empreinte carbone et économie circulaire
 - [ ] Création d'emplois qualifiés et formation
 - [ ] Rayonnement technologique et attractivité territoriale
 ## 12. Annexes
 ### Annexe A - Spécifications système détaillées
 **Requirements Database :**
 - Exigences fonctionnelles avec critères d'acceptation
 - Exigences non-fonctionnelles et contraintes
 - Matrice de traçabilité complète
 - Historique des évolutions et justifications
 ### Annexe B - Analyses et simulations
 **Modèles numériques :**
 - Modèles CAO 3D assemblage complet
 - Simulations multiphysiques (thermique, mécanique, fluidique)
 - Analyses de fiabilité et sûreté de fonctionnement
 - Optimisations et études de sensibilité
 ### Annexe C - Plan de tests et validation
 **Stratégie de validation :**
 - Matrice tests vs exigences
 - Protocoles détaillés par niveau d'intégration
 - Critères d'acceptation et procédures non-conformité
 - Planning et ressources tests
 ### Annexe D - Business case et valorisation
 **Analyse économique :**
 - Modèle financier et projections ROI
 - Analyse concurrentielle et positionnement marché
 - Stratégie de propriété intellectuelle
 - Plan de commercialisation et go-to-market
 ### Annexe E - Gestion des risques
 **Risk Register complet :**
 - Identification et évaluation des risques
 - Plans de mitigation et actions préventives
 - Suivi et reporting des risques critiques
 - Procédures de crise et plans de contingence
 ---
 *Journal créé le : [DATE]*
 *Dernière mise à jour : [DATE]*
 *Classification : [Confidentiel/Restreint/Public]*
 *Chef de projet : [Nom et contact]*
--- a/templates/ingenierie/detaille.md
+++ b/templates/ingenierie/detaille.md
@ -1,149 +0,0 @@
 # Journal de Conception - Projet Ingénierie (Détaillé)
 ## 1. Introduction
 **Présentation du contexte d'ingénierie :**
 [Décrire l'environnement technique, les systèmes existants, les défis d'ingénierie et la problématique à résoudre]
 **Idée principale du projet :**
 [Résumer la solution d'ingénierie proposée, l'innovation technique et l'approche méthodologique]
 ## 2. Objectifs du projet
 **Objectifs principaux :**
 - [ ] **Objectif de performance** : [Spécifications techniques, rendement, efficacité]
 - [ ] **Objectif de fiabilité** : [Durabilité, maintenance, disponibilité]
 - [ ] **Objectif d'innovation** : [Avancées techniques, brevets, différenciation]
 **Spécifications techniques recherchées :**
 - **Performance** : Caractéristiques quantifiées du système
 - **Fiabilité** : MTBF, taux de panne, maintenabilité
 - **Sécurité** : Analyses de risque, conformité normative
 - **Économie** : Coûts de développement et exploitation
 ## 3. Organisation du document
 Ce journal suit la méthodologie d'ingénierie système :
 - **Sections 1-4** : Expression du besoin et spécifications (cahier des charges)
 - **Sections 5-6** : Conception et dimensionnement (solutions techniques)
 - **Sections 7-8** : Réalisation et tests (validation expérimentale)
 - **Sections 9-10** : Industrialisation et exploitation (déploiement)
 ## 4. Présentation et spécifications du projet
 **Description technique détaillée :**
 [Expliquer le système d'ingénierie, ses fonctions principales et son environnement opérationnel]
 **Cahier des charges technique :**
 - **Fonction principale** : [Service rendu par le système]
 - **Fonctions contraintes** : [Limites et conditions d'utilisation]
 - **Critères de performance** : [Mesures quantitatives de réussite]
 **Diagrammes fonctionnels :**
 ```
 Environnement → [Système] → Fonction principale
               ↑
         Fonctions contraintes
 ```
 ## 5. Fonctionnalités attendues
 - [ ] **Analyse fonctionnelle** : FAST, SADT, cas d'usage système
 - [ ] **Conception détaillée** : Dimensionnement, choix technologiques
 - [ ] **Simulations** : Modélisation comportementale, validation numérique
 - [ ] **Prototypage** : Maquettes, essais, validation expérimentale
 - [ ] **Industrialisation** : Processus de fabrication, contrôle qualité
 ## 6. Conception globale
 **Approche d'ingénierie système :**
 ```
 Besoin → Spécifications → Conception → Réalisation → Validation → Exploitation
 ```
 **Architecture technique :**
 - **Sous-système 1** : [Fonction, interfaces, performances]
 - **Sous-système 2** : [Fonction, interfaces, performances]
 - **Intégration** : [Interfaces, protocoles, synchronisation]
 - **Supervision** : [Contrôle, monitoring, maintenance]
 ## 7. Problématiques identifiées et solutions envisagées
 | Défi d'ingénierie | Solutions techniques |
 |-------------------|---------------------|
 | Optimisation thermique | Simulation CFD, matériaux haute conductivité |
 | Vibrations et bruit | Analyse modale, amortissement actif |
 | Fiabilité électronique | Composants qualifiés, redondance |
 | Coûts de production | DFM, standardisation, automatisation |
 ## 8. Environnement et outils de travail
 **Outils de conception :**
 - **CAO 3D** : SolidWorks, Inventor, CATIA
 - **Calculs** : MATLAB, Python, feuilles de calcul
 - **Simulation** : ANSYS (mécanique), COMSOL (multiphysique)
 - **PLM** : Gestion du cycle de vie produit
 **Outils de validation :**
 - **Prototypage** : Impression 3D, usinage, électronique
 - **Mesures** : Oscilloscopes, analyseurs, capteurs
 - **Tests** : Bancs d'essais, chambres climatiques
 - **Normes** : Standards industriels, certifications
 ## 9. Phases du projet et planification
 **Phase 1 - Étude de faisabilité (4 semaines) :**
 - [ ] Analyse du besoin et spécifications
 - [ ] État de l'art technologique
 - [ ] Études de faisabilité technique et économique
 **Phase 2 - Conception préliminaire (6 semaines) :**
 - [ ] Architecture système et décomposition fonctionnelle
 - [ ] Dimensionnement et choix technologiques
 - [ ] Simulations numériques et validation théorique
 **Phase 3 - Conception détaillée (8 semaines) :**
 - [ ] Conception détaillée des sous-systèmes
 - [ ] Plans de fabrication et nomenclatures
 - [ ] Analyses de fiabilité et de sécurité
 **Phase 4 - Prototypage et tests (6 semaines) :**
 - [ ] Réalisation de prototypes
 - [ ] Campagnes d'essais et validation expérimentale
 - [ ] Optimisations et corrections
 **Phase 5 - Industrialisation (4 semaines) :**
 - [ ] Processus de fabrication et contrôle qualité
 - [ ] Documentation technique et maintenance
 - [ ] Formation et transfert de compétences
 ## 10. Gestion de projet (méthode en V)
 **Approche systématique :**
 - Cycle en V avec validation à chaque étape
 - Reviews techniques avec experts métier
 - Gestion des risques techniques et planning
 - Traçabilité des exigences et vérifications
 **Indicateurs de progression :**
 - Jalons techniques atteints
 - Performances mesurées vs spécifications
 - Taux de non-conformité et actions correctives
 - Respect des délais et budgets
 ## 11. Conclusion
 **Contributions techniques attendues :**
 [Résumer l'innovation d'ingénierie, les performances obtenues et l'impact industriel]
 **Valorisation technique :**
 [Brevets, publications, transfert technologique]
 **Perspectives d'amélioration :**
 - [ ] Optimisations de performance
 - [ ] Réduction des coûts
 - [ ] Extensions fonctionnelles
 - [ ] Évolutions technologiques
 ## 12. Annexes
 **Calculs de dimensionnement :**
 [Notes de calculs, hypothèses, résultats numériques]
 **Résultats d'essais :**
 [Protocoles de tests, mesures, analyses]
 **Plans et spécifications :**
 [Dessins techniques, nomenclatures, spécifications fournisseurs]
 ---
 *Journal créé le : [DATE]*
 *Dernière mise à jour : [DATE]*
--- a/templates/ingenierie/simple.md
+++ b/templates/ingenierie/simple.md
@ -1,94 +0,0 @@
 # Journal de Conception - Projet Ingénierie
 ## 1. Introduction
 **Contexte du projet :**
 [Décrire brièvement le problème d'ingénierie à résoudre]
 **Idée principale :**
 [Résumer la solution technique et l'approche d'ingénierie en une phrase]
 ## 2. Objectifs du projet
 **Objectifs principaux :**
 - [ ] Objectif technique
 - [ ] Objectif performance
 - [ ] Objectif qualité
 **Spécifications clés :**
 - Performance requise
 - Contraintes techniques
 - Standards à respecter
 ## 3. Présentation et spécifications
 **Description détaillée :**
 [Expliquer le projet d'ingénierie et ses enjeux techniques]
 **Cahier des charges :**
 - **Fonction principale** : [Besoin technique à satisfaire]
 - **Contraintes** : [Limites physiques, budgétaires, normatives]
 - **Critères de réussite** : [Métriques de performance]
 ## 4. Fonctionnalités attendues
 - [ ] **Conception** : Dimensionnement et calculs
 - [ ] **Modélisation** : Simulations et analyses
 - [ ] **Prototypage** : Tests et validation
 - [ ] **Industrialisation** : Mise en production
 ## 5. Conception globale
 **Cycle en V :**
 ```
 Spécifications → Conception → Réalisation → Tests → Validation
 ```
 **Approche système :**
 - **Analyse fonctionnelle** : Expression du besoin
 - **Conception détaillée** : Solutions techniques
 - **Intégration** : Assemblage et mise au point
 - **Validation** : Conformité aux spécifications
 ## 6. Problématiques et solutions
 | Défi technique | Solution envisagée |
 |----------------|-------------------|
 | Performance thermique | Simulation CFD, matériaux |
 | Fiabilité système | Redondance, tests MTBF |
 | Coûts production | Optimisation design, matériaux |
 ## 7. Environnement et outils
 **Outils d'ingénierie :**
 - CAO : SolidWorks, AutoCAD, Inventor
 - Simulation : ANSYS, COMSOL, Simulink
 - Calculs : MATLAB, Excel, Python
 - Gestion : PLM, ERP
 **Normes et standards :**
 - Normes industrielles applicables
 - Certifications requises
 - Réglementations à respecter
 ## 8. Phases du projet
 **Phase 1 - Étude (3 semaines) :**
 - [ ] Analyse du besoin
 - [ ] État de l'art technique
 - [ ] Avant-projet sommaire
 **Phase 2 - Conception (6 semaines) :**
 - [ ] Calculs de dimensionnement
 - [ ] Modélisation et simulations
 - [ ] Plans et spécifications
 **Phase 3 - Réalisation (4 semaines) :**
 - [ ] Prototypage
 - [ ] Tests et mesures
 - [ ] Optimisations
 ## 9. Conclusion
 **État d'avancement :**
 [À compléter au fur et à mesure]
 **Prochaines étapes :**
 - [ ] Validation concept technique
 - [ ] Réalisation prototype
 - [ ] Tests de performance
 ---
 *Journal créé le : [DATE]*
 *Dernière mise à jour : [DATE]*
--- a/templates/math/complet.md
+++ b/templates/math/complet.md
@ -1,322 +0,0 @@
 # Journal de Conception - Projet Mathématiques (Complet)
 ## 1. Introduction
 **Présentation du contexte mathématique :**
 [Décrire le domaine mathématique, les fondements théoriques, les enjeux scientifiques et la problématique formelle à résoudre]
 **Idée principale du projet :**
 [Résumer l'approche méthodologique, les innovations théoriques, les modèles envisagés et les contributions attendues]
 **Positionnement dans la littérature mathématique :**
 [Situer le travail par rapport aux résultats existants, identifier les gaps théoriques et les défis ouverts]
 ## 2. Objectifs du projet
 **Objectifs principaux :**
 - [ ] **Objectif théorique** : [Développement nouveaux théorèmes, preuves, structures algébriques]
 - [ ] **Objectif algorithmique** : [Conception méthodes de calcul, optimisation, complexité]
 - [ ] **Objectif appliqué** : [Résolution problèmes concrets, modélisation phénomènes réels]
 **Problèmes mathématiques à résoudre :**
 - **Problème principal** : [Énoncé mathématique précis, hypothèses, objectifs]
 - **Sous-problèmes** :
  - [Lemme 1 : résultat intermédiaire nécessaire]
  - [Lemme 2 : cas particulier à établir d'abord]
  - [Corollaire : conséquence du résultat principal]
 **Conjectures et hypothèses :**
 - **Conjecture principale** : [Énoncé à démontrer avec conditions]
 - **Hypothèses de travail** : [Conditions techniques, domaines de validité]
 - **Contre-exemples potentiels** : [Cas limites à examiner]
 ## 3. Organisation du document
 Ce journal suit la démarche mathématique rigoureuse :
 - **Sections 1-4** : Fondements théoriques (définitions, état de l'art)
 - **Sections 5-6** : Développement mathématique (théorèmes, preuves)
 - **Sections 7-8** : Implémentation et validation (algorithmes, tests)
 - **Sections 9-10** : Applications et extensions (cas d'étude, généralisations)
 ## 4. Présentation et spécifications du projet
 **Description mathématique détaillée :**
 [Expliquer le problème mathématique, ses enjeux théoriques, son contexte d'application et sa complexité]
 **Formulation mathématique précise :**
 ### 4.1 Définitions et notations
 **Espaces de travail :**
 - $X$ : [Espace de définition, structure, propriétés]
 - $Y$ : [Espace d'arrivée, topologie, mesure]
 - $\mathcal{F}$ : [Classe de fonctions considérées]
 **Opérateurs et fonctionnelles :**
 - $T : X \to Y$ : [Opérateur principal étudié]
 - $L(f,g) = \int \phi(f,g) \, d\mu$ : [Fonctionnelle objectif]
 - $\|\cdot\|_p$ : [Normes utilisées, $1 \leq p \leq \infty$]
 ### 4.2 Énoncé du problème principal
 **Théorème à démontrer :**
 > **Théorème Principal.** *Soit $(X,d)$ un espace métrique compact et $f : X \to \mathbb{R}$ une fonction continue. Alors il existe une constante $C > 0$ telle que pour tout $\epsilon > 0$, on peut trouver $g \in \mathcal{C}^{\infty}(X)$ vérifiant :*
 > $$\|f - g\|_{\infty} < \epsilon \quad \text{et} \quad \|g\|_{\text{Lip}} \leq C \|f\|_{\infty}$$
 **Conditions et hypothèses :**
 - $X$ compact métrisable
 - $f$ uniformément continue
 - $\mathcal{C}^{\infty}(X)$ dense dans $\mathcal{C}(X)$
 ## 5. Fonctionnalités attendues
 ### 5.1 Développement théorique
 - [ ] **Lemmes préparatoires** : Résultats techniques nécessaires
 - [ ] **Théorème principal** : Démonstration constructive
 - [ ] **Corollaires** : Conséquences et cas particuliers
 - [ ] **Applications** : Utilisation dans d'autres contextes
 ### 5.2 Analyse de complexité
 - [ ] **Complexité temporelle** : Estimation du coût de calcul
 - [ ] **Complexité spatiale** : Besoin en mémoire
 - [ ] **Optimisations** : Améliorations algorithmiques
 - [ ] **Bornes inférieures** : Limites théoriques
 ### 5.3 Implémentation numérique
 - [ ] **Algorithmes** : Méthodes de calcul effectives
 - [ ] **Convergence** : Preuves de convergence, vitesse
 - [ ] **Stabilité numérique** : Analyse des erreurs d'arrondi
 - [ ] **Tests** : Validation sur exemples théoriques
 ### 5.4 Validation et benchmarks
 - [ ] **Cas tests** : Exemples dont la solution est connue
 - [ ] **Comparaisons** : Avec méthodes existantes
 - [ ] **Limites** : Domaines de validité, contre-exemples
 - [ ] **Performance** : Métriques de qualité
 ## 6. Conception globale
 **Démarche mathématique :**
 ```
 Intuition → Formalisation → Conjectures → Preuves → Algorithmes → Validation
 ```
 **Architecture théorique :**
 - **Couche fondamentale** : Axiomes, définitions de base
 - **Couche structurelle** : Théorèmes généraux, propriétés
 - **Couche algorithmique** : Méthodes de calcul, implémentation
 - **Couche applicative** : Problèmes concrets, cas d'étude
 ### 6.1 Structure des preuves
 **Stratégie de démonstration :**
 1. **Réduction** : Ramener au cas simple
 2. **Construction** : Méthode explicite
 3. **Existence** : Argument topologique/algébrique
 4. **Unicité** : Caractérisation de la solution
 **Outils mathématiques utilisés :**
 - **Analyse fonctionnelle** : Espaces de Banach, opérateurs compacts
 - **Topologie** : Compacité, connexité, théorèmes de point fixe
 - **Mesure** : Intégration, convergence faible
 - **Algèbre** : Structures, morphismes, quotients
 ## 7. Problématiques identifiées et solutions envisagées
 | Problématique mathématique | Solutions théoriques |
 |----------------------------|---------------------|
 | Non-unicité des solutions | Critères de sélection, régularisation |
 | Convergence lente | Méthodes d'accélération, préconditionnement |
 | Instabilité numérique | Reformulation stable, contrôle d'erreur |
 | Complexité élevée | Approximations, méthodes hiérarchiques |
 ### 7.1 Défis théoriques spécifiques
 **Problème de régularité :**
 - Solutions généralisées vs solutions classiques
 - Conditions de différentiabilité
 - Singularités et points critiques
 **Problème d'existence :**
 - Compacité des suites minimisantes
 - Principe variationnel
 - Théorèmes de point fixe appropriés
 ## 8. Environnement et outils de travail
 **Outils de calcul symbolique :**
 - **CAS** : Mathematica, Maple, SageMath
 - **Preuves assistées** : Coq, Lean, Isabelle/HOL
 - **Visualisation** : Matplotlib, Plotly, GeoGebra
 **Bibliothèques numériques :**
 - **Python** : NumPy, SciPy, SymPy, scikit-learn
 - **Julia** : DifferentialEquations.jl, Plots.jl
 - **R** : Base stats, specialized packages
 - **C++** : Eigen, BLAS/LAPACK, custom implementations
 **Rédaction scientifique :**
 - **LaTeX** : Avec packages spécialisés (amsmath, theorem)
 - **Jupyter/Sage** : Notebooks reproductibles
 - **Git** : Versioning des preuves et codes
 - **arXiv** : Prépublication et diffusion
 ## 9. Phases du projet et planification
 ### Phase 1 - Fondements théoriques (8 semaines)
 **Semaines 1-2 : État de l'art approfondi**
 - [ ] Revue littérature exhaustive
 - [ ] Analyse des méthodes existantes
 - [ ] Identification des gaps théoriques
 **Semaines 3-4 : Formalisation du problème**
 - [ ] Définitions précises et notations
 - [ ] Énoncé rigoureux des conjectures
 - [ ] Étude des cas particuliers simples
 **Semaines 5-6 : Développement des outils**
 - [ ] Lemmes techniques nécessaires
 - [ ] Contre-exemples et cas limites
 - [ ] Stratégie générale de preuve
 **Semaines 7-8 : Premiers résultats**
 - [ ] Résultats partiels
 - [ ] Validation approche théorique
 - [ ] **Livrable** : Note technique préliminaire
 ### Phase 2 - Développement principal (12 semaines)
 **Semaines 9-12 : Théorème principal**
 - [ ] Démonstration détaillée
 - [ ] Vérification rigoureuse
 - [ ] Analyse des hypothèses
 **Semaines 13-16 : Extensions et corollaires**
 - [ ] Généralisations possibles
 - [ ] Applications à des cas particuliers
 - [ ] Optimisation des constantes
 **Semaines 17-20 : Validation théorique**
 - [ ] Peer review interne
 - [ ] Vérification indépendante
 - [ ] **Livrable** : Preprint arXiv
 ### Phase 3 - Implémentation numérique (10 semaines)
 **Semaines 21-24 : Algorithmes**
 - [ ] Traduction des preuves en algorithmes
 - [ ] Analyse de convergence numérique
 - [ ] Optimisation des performances
 **Semaines 25-28 : Tests et validation**
 - [ ] Batteries de tests exhaustives
 - [ ] Comparaison avec méthodes existantes
 - [ ] Analyse de robustesse
 **Semaines 29-30 : Documentation**
 - [ ] Code documenté et reproductible
 - [ ] Manuel utilisateur
 - [ ] **Livrable** : Package logiciel
 ### Phase 4 - Applications et diffusion (6 semaines)
 **Semaines 31-33 : Applications**
 - [ ] Cas d'étude concrets
 - [ ] Problèmes industriels/scientifiques
 - [ ] Retour d'expérience utilisateurs
 **Semaines 34-36 : Publication**
 - [ ] Rédaction article journal
 - [ ] Soumission conférence internationale
 - [ ] **Livrable** : Publications scientifiques
 ## 10. Gestion de projet (Mathématiques collaboratives)
 **Approche collaborative :**
 - Séminaires réguliers équipe
 - Reviews par pairs internationaux
 - Collaborations inter-institutionnelles
 - Workshops spécialisés
 **Validation scientifique :**
 - Vérification croisée des preuves
 - Implémentation indépendante
 - Tests sur benchmarks standards
 - Peer review avant publication
 **Métriques de progression :**
 - Lemmes démontrés / total
 - Tests de convergence validés
 - Lignes de code documentées
 - Citations et reconnaissance
 ## 11. Conclusion
 **Contributions mathématiques attendues :**
 [Résumer l'avancement théorique, les innovations méthodologiques et l'impact scientifique]
 **Applications et retombées :**
 [Domaines d'application, transfert vers l'industrie, enseignement]
 **Perspectives de développement :**
 - [ ] Extensions à d'autres espaces fonctionnels
 - [ ] Généralisation aux dimensions infinies
 - [ ] Applications en physique mathématique
 - [ ] Connexions avec d'autres domaines
 **Impact sur la communauté :**
 - [ ] Nouvelles méthodes disponibles
 - [ ] Outils logiciels partagés
 - [ ] Formation doctorants/chercheurs
 - [ ] Collaborations renforcées
 ## 12. Annexes
 ### Annexe A - Démonstrations complètes
 **Théorème principal :**
 *Preuve.* [Démonstration détaillée avec toutes les étapes]
 **Lemmes techniques :**
 - Lemme A.1 : [Énoncé et preuve]
 - Lemme A.2 : [Énoncé et preuve]
 - Corollaire A.3 : [Conséquence directe]
 ### Annexe B - Algorithmes détaillés
 ```python
 def algorithm_principal(input_data, tolerance=1e-6):
    """
    Implémentation du théorème principal.
    Parameters:
    -----------
    input_data : array_like
        Données d'entrée satisfaisant les hypothèses
    tolerance : float
        Précision souhaitée pour la convergence
    Returns:
    --------
    solution : array_like
        Solution approximative du problème
    convergence_info : dict
        Informations sur la convergence
    """
    # Initialisation
    solution = initialize_solution(input_data)
    # Itérations principales
    for iteration in range(max_iterations):
        # Étape de mise à jour selon le théorème
        solution = update_step(solution, input_data)
        # Test de convergence
        if convergence_test(solution, tolerance):
            break
    return solution, {"iterations": iteration, "converged": True}
 ```
 ### Annexe C - Benchmarks et performances
 **Tests de validation :**
 - Cas tests analytiques avec solutions exactes
 - Comparaisons avec méthodes de référence
 - Analyse de complexité empirique
 - Profiling des performances
 **Résultats numériques :**
 | Test Case | Our Method | Reference | Speedup | Accuracy |
 |-----------|------------|-----------|---------|----------|
 | Test 1    | 0.15s     | 1.2s      | 8.0x    | 1e-12   |
 | Test 2    | 0.32s     | 2.1s      | 6.6x    | 1e-11   |
 ### Annexe D - Code source complet
 [Repository Git avec code documenté, tests, exemples]
 ### Annexe E - Données expérimentales
 [Fichiers de données, scripts de génération, résultats bruts]
 ---
 *Journal créé le : [DATE]*
 *Dernière mise à jour : [DATE]*
 *Statut publication : [Preprint/Submitted/Published]*
 *Collaborateurs : [Liste des co-auteurs]*
--- a/templates/math/detaille.md
+++ b/templates/math/detaille.md
@ -1,141 +0,0 @@
 # Journal de Conception - Projet Mathématiques (Détaillé)
 ## 1. Introduction
 **Présentation du contexte mathématique :**
 [Décrire le domaine d'application, les enjeux théoriques ou pratiques et la problématique mathématique]
 **Idée principale du projet :**
 [Résumer l'approche méthodologique, les modèles envisagés et l'innovation scientifique]
 ## 2. Objectifs du projet
 **Objectifs principaux :**
 - [ ] **Objectif théorique** : [Développement de nouveaux modèles, preuves, algorithmes]
 - [ ] **Objectif appliqué** : [Résolution d'un problème concret par les mathématiques]
 - [ ] **Objectif méthodologique** : [Validation ou amélioration de méthodes existantes]
 **Fonctionnalités clés recherchées :**
 - **Modélisation** : Représentation mathématique du problème
 - **Analyse** : Étude théorique des propriétés du modèle
 - **Simulation** : Implémentation et tests numériques
 - **Validation** : Vérification sur données réelles ou cas d'étude
 ## 3. Organisation du document
 Ce journal suit la démarche scientifique mathématique :
 - **Sections 1-4** : Cadre théorique et spécifications (fondements solides)
 - **Sections 5-6** : Modélisation et développement (cœur mathématique)
 - **Sections 7-8** : Implémentation et tests (validation pratique)
 - **Sections 9-10** : Résultats et analyse (contributions scientifiques)
 ## 4. Présentation et spécifications du projet
 **Description détaillée :**
 [Expliquer le problème mathématique, ses enjeux et son contexte d'application]
 **Cahier des charges mathématique :**
 - **Problème général** : [Formulation mathématique précise]
 - **Contraintes spécifiques** : [Conditions aux limites, hypothèses, domaines de validité]
 - **Variables et paramètres** : [Définition de l'espace des solutions]
 **Diagrammes et formulations :**
 ```
 Modèle mathématique :
 f: X → Y
 où X = domaine d'entrée
   Y = espace des solutions
 ```
 ## 5. Fonctionnalités attendues
 - [ ] **Modélisation théorique** : Équations, systèmes, espaces fonctionnels
 - [ ] **Algorithmes de résolution** : Méthodes analytiques ou numériques
 - [ ] **Simulation numérique** : Implémentation Python/R/Matlab
 - [ ] **Validation statistique** : Tests, intervalles de confiance, significativité
 - [ ] **Visualisation** : Graphiques, surfaces, animations des résultats
 ## 6. Conception globale
 **Approche mathématique :**
 ```
 Problème réel → Modélisation → Analyse théorique → Simulation → Interprétation
 ```
 **Architecture de la solution :**
 - **Couche théorique** : Définitions, théorèmes, démonstrations
 - **Couche algorithmique** : Méthodes de calcul et d'optimisation
 - **Couche computationnelle** : Code, simulations, tests numériques
 - **Couche validation** : Comparaisons, benchmarks, études de cas
 ## 7. Problématiques identifiées et solutions envisagées
 | Problématique mathématique | Solutions envisagées |
 |----------------------------|---------------------|
 | Convergence des algorithmes | Analyse de stabilité, critères d'arrêt |
 | Complexité computationnelle | Approximations, méthodes hybrides |
 | Validité du modèle | Tests statistiques, validation croisée |
 ## 8. Environnement et outils de travail
 **Outils mathématiques :**
 - **Calcul symbolique** : Mathematica, Maple, SymPy
 - **Calcul numérique** : Python (NumPy, SciPy), R, Matlab
 - **Visualisation** : Matplotlib, ggplot2, Plotly
 - **Rédaction** : LaTeX, Jupyter Notebooks, RMarkdown
 **Bibliothèques spécialisées :**
 - Optimisation : scipy.optimize, cvxpy
 - Statistiques : statsmodels, scikit-learn
 - Calcul parallèle : numba, multiprocessing
 ## 9. Phases du projet et planification
 **Phase 1 - Étude théorique (4 semaines) :**
 - [ ] Revue de littérature et état de l'art
 - [ ] Formalisation mathématique du problème
 - [ ] Développement théorique initial
 **Phase 2 - Développement méthodologique (6 semaines) :**
 - [ ] Conception des algorithmes
 - [ ] Preuves de convergence et stabilité
 - [ ] Analyse de complexité
 **Phase 3 - Implémentation et tests (4 semaines) :**
 - [ ] Programmation des méthodes
 - [ ] Tests unitaires et validation
 - [ ] Optimisation des performances
 **Phase 4 - Validation et analyse (3 semaines) :**
 - [ ] Tests sur cas d'étude
 - [ ] Analyse comparative avec méthodes existantes
 - [ ] Rédaction des résultats
 ## 10. Gestion de projet (méthode scientifique)
 **Approche itérative :**
 - Hypothèse → Développement → Test → Refinement
 - Revue par les pairs à chaque étape majeure
 - Documentation continue des résultats intermédiaires
 **Indicateurs de progression :**
 - Théorèmes démontrés
 - Algorithmes validés
 - Tests réussis
 - Publications/présentations
 ## 11. Conclusion
 **Contributions attendues :**
 [Résumer les apports théoriques et pratiques du projet]
 **Applications potentielles :**
 [Domaines où les résultats peuvent être appliqués]
 **Perspectives d'extension :**
 - [ ] Généralisation à d'autres cas
 - [ ] Applications à des domaines connexes
 - [ ] Développements théoriques futurs
 ## 12. Annexes
 **Démonstrations détaillées :**
 [Preuves mathématiques complètes]
 **Code source :**
 [Scripts Python/R avec documentation]
 **Données et résultats :**
 [Jeux de données, graphiques, tableaux de résultats]
 ---
 *Journal créé le : [DATE]*
 *Dernière mise à jour : [DATE]*
--- a/templates/math/simple.md
+++ b/templates/math/simple.md
@ -1,92 +0,0 @@
 # Journal de Conception - Projet Mathématiques
 ## 1. Introduction
 **Contexte du projet :**
 [Décrire brièvement le problème mathématique à résoudre]
 **Idée principale :**
 [Résumer l'approche méthodologique envisagée en une phrase]
 ## 2. Objectifs du projet
 **Objectifs principaux :**
 - [ ] Objectif théorique
 - [ ] Objectif appliqué
 - [ ] Objectif méthodologique
 **Résultats recherchés :**
 - Nouveaux théorèmes ou preuves
 - Applications pratiques
 - Méthodes de calcul
 ## 3. Présentation et spécifications
 **Description détaillée :**
 [Expliquer ce que fait le projet et ses enjeux mathématiques]
 **Cahier des charges :**
 - **Problème général** : [Formulation mathématique]
 - **Hypothèses** : [Conditions et contraintes]
 - **Domaine de validité** : [Espace des solutions]
 ## 4. Fonctionnalités attendues
 - [ ] **Modélisation** : Représentation mathématique du problème
 - [ ] **Analyse théorique** : Étude des propriétés
 - [ ] **Calculs numériques** : Algorithmes et implémentation
 - [ ] **Validation** : Tests sur cas connus
 ## 5. Conception globale
 **Approche mathématique :**
 ```
 Problème → Modélisation → Analyse → Calculs → Validation
 ```
 **Méthodes utilisées :**
 - **Outils analytiques** : Analyse, algèbre, topologie
 - **Outils numériques** : Algorithmes, approximations
 - **Logiciels** : Python/Matlab, bibliothèques spécialisées
 ## 6. Problématiques et solutions
 | Difficulté | Solution envisagée |
 |------------|-------------------|
 | Complexité théorique | Décomposition en sous-problèmes |
 | Convergence numérique | Méthodes adaptatives |
 | Validation résultats | Tests sur cas analytiques |
 ## 7. Environnement et outils
 **Outils mathématiques :**
 - Calcul symbolique : Mathematica, Sage
 - Calcul numérique : Python (NumPy, SciPy)
 - Visualisation : Matplotlib, plots 3D
 **Références :**
 - Ouvrages de référence
 - Articles scientifiques
 - Cours et supports
 ## 8. Phases du projet
 **Phase 1 - Étude théorique (3 semaines) :**
 - [ ] Revue de littérature
 - [ ] Formalisation du problème
 - [ ] Premiers résultats analytiques
 **Phase 2 - Implémentation (3 semaines) :**
 - [ ] Algorithmes de calcul
 - [ ] Tests numériques
 - [ ] Validation des résultats
 **Phase 3 - Application (2 semaines) :**
 - [ ] Cas d'étude
 - [ ] Optimisations
 - [ ] Documentation finale
 ## 9. Conclusion
 **État d'avancement :**
 [À compléter au fur et à mesure]
 **Prochaines étapes :**
 - [ ] Démonstration du théorème principal
 - [ ] Implémentation numérique
 - [ ] Rédaction des résultats
 ---
 *Journal créé le : [DATE]*
 *Dernière mise à jour : [DATE]*
--- a/templates/recherche/complet.md
+++ b/templates/recherche/complet.md
@ -1,258 +0,0 @@
 # Journal de Conception - Projet de Recherche (Complet)
 ## 1. Introduction
 **Présentation du contexte scientifique :**
 [Décrire le domaine de recherche, l'état de l'art, les verrous scientifiques et la problématique de recherche]
 **Idée principale du projet :**
 [Résumer l'hypothèse de recherche, la méthodologie proposée et l'innovation scientifique attendue]
 **Positionnement dans la littérature :**
 [Situer la recherche par rapport aux travaux existants, identifier les gaps de connaissance]
 ## 2. Objectifs du projet
 **Objectifs principaux :**
 - [ ] **Objectif scientifique** : [Contribution à la connaissance, théorie à développer/valider]
 - [ ] **Objectif méthodologique** : [Nouvelles méthodes, outils, protocoles]
 - [ ] **Objectif applicatif** : [Retombées pratiques, transfert technologique]
 **Questions de recherche :**
 - **Question principale** : [Problématique centrale de la recherche]
 - **Questions secondaires** :
  - [Sous-question 1 avec hypothèse associée]
  - [Sous-question 2 avec hypothèse associée]
  - [Sous-question 3 avec hypothèse associée]
 **Hypothèses de travail :**
 - **H1** : [Hypothèse principale avec prédictions testables]
 - **H2** : [Hypothèse secondaire avec variables mesurables]
 - **H3** : [Hypothèse alternative ou nulle]
 ## 3. Organisation du document
 Ce journal suit la démarche scientifique rigoureuse :
 - **Sections 1-4** : Fondements théoriques (état de l'art, hypothèses)
 - **Sections 5-6** : Méthodologie et design expérimental (protocole)
 - **Sections 7-8** : Collecte et analyse données (résultats)
 - **Sections 9-10** : Interprétation et discussion (contributions)
 ## 4. Présentation et spécifications du projet
 **Description détaillée :**
 [Expliquer le projet de recherche, ses enjeux scientifiques et son contexte académique/industriel]
 **État de l'art approfondi :**
 ### 4.1 Revue de littérature systématique
 - **Domaines connexes** : [Champs disciplinaires impliqués]
 - **Travaux fondateurs** : [Références clés et contributions historiques]
 - **Recherches récentes** : [Dernières avancées, 2020-2025]
 - **Gaps identifiés** : [Manques dans la connaissance actuelle]
 ### 4.2 Positionnement théorique
 - **Cadre conceptuel** : [Théories et modèles de référence]
 - **Paradigme de recherche** : [Approche positiviste/constructiviste/pragmatique]
 - **Ancrage disciplinaire** : [Mono/inter/transdisciplinaire]
 **Cahier des charges scientifique :**
 - **Objectifs opérationnels** : [Résultats attendus mesurables]
 - **Contraintes méthodologiques** : [Limites, biais potentiels, validité]
 - **Critères de validation** : [Métriques de success, seuils statistiques]
 ## 5. Fonctionnalités attendues
 ### 5.1 Recherche bibliographique approfondie
 - [ ] **Veille scientifique** : Surveillance littérature, alertes
 - [ ] **Base de données** : Constitution corpus, classification
 - [ ] **Analyse bibliométrique** : Citations, réseaux, tendances
 ### 5.2 Design expérimental
 - [ ] **Protocole expérimental** : Plans d'expérience, contrôles
 - [ ] **Instrumentation** : Outils de mesure, validation métrologique
 - [ ] **Échantillonnage** : Stratégie de recrutement, taille échantillon
 ### 5.3 Collecte et gestion des données
 - [ ] **Data collection** : Protocoles standardisés, formation enquêteurs
 - [ ] **Data management** : FAIR principles, stockage sécurisé
 - [ ] **Quality assurance** : Validation, nettoyage, documentation
 ### 5.4 Analyse et interprétation
 - [ ] **Analyses statistiques** : Tests appropriés, puissance, effect size
 - [ ] **Modélisation** : Modèles prédictifs, simulation
 - [ ] **Visualisation** : Graphiques scientifiques, figures publication
 ## 6. Conception globale
 **Paradigme de recherche :**
 ```
 Observation → Théorisation → Hypothèses → Expérimentation → Validation → Généralisation
 ```
 **Architecture méthodologique :**
 - **Couche épistémologique** : Fondements philosophiques, posture du chercheur
 - **Couche théorique** : Cadres conceptuels, modèles explicatifs
 - **Couche méthodologique** : Stratégies de recherche, design études
 - **Couche opérationnelle** : Techniques collecte/analyse, outils
 ### 6.1 Design de recherche
 **Type d'étude :** [Expérimentale/Observationnelle/Mixte]
 **Devis :** [Longitudinal/Transversal/Cas-témoins]
 **Population :** [Critères inclusion/exclusion, stratification]
 ### 6.2 Variables d'étude
 **Variables indépendantes (VI) :**
 - VI1 : [Nom, opérationnalisation, niveaux/modalités]
 - VI2 : [Facteur contrôlé, manipulation expérimentale]
 **Variables dépendantes (VD) :**
 - VD1 : [Outcome primaire, mesure, unité]
 - VD2 : [Outcome secondaire, indicateurs]
 **Variables de contrôle :**
 - [Covariables, facteurs confondants, randomisation]
 ## 7. Problématiques identifiées et solutions envisagées
 | Problématique méthodologique | Solutions scientifiques |
 |------------------------------|------------------------|
 | Validité interne | Randomisation, contrôles, aveugle |
 | Validité externe | Échantillon représentatif, réplication |
 | Puissance statistique | Calcul taille effet, analysis plan |
 | Biais de publication | Pré-registration, open science |
 ### 7.1 Considérations éthiques
 - **Comité d'éthique** : [Soumission, approbation]
 - **Consentement éclairé** : [Procédure, information participants]
 - **Confidentialité** : [Anonymisation, protection données]
 - **Risques/bénéfices** : [Évaluation, minimisation risques]
 ## 8. Environnement et outils de travail
 **Infrastructure de recherche :**
 - **Laboratoire** : [Équipements, certifications, sécurité]
 - **Plateformes techniques** : [Instruments spécialisés, collaborations]
 - **Computing** : [HPC, cloud, logiciels analyse]
 **Outils de recherche :**
 - **Référencement** : Zotero, Mendeley, EndNote
 - **Analyse qualitative** : NVivo, ATLAS.ti, MAXQDA
 - **Analyse quantitative** : R, Python, SPSS, SAS
 - **Rédaction** : LaTeX, Word, collaborative tools
 **Gestion projet recherche :**
 - **Planning** : Gantt, milestones scientifiques
 - **Collaboration** : Git, shared repositories
 - **Documentation** : Lab notebooks, protocols.io
 - **Partage** : Open Science Framework, repositories
 ## 9. Phases du projet et planification
 ### Phase 1 - Préparation et Design (6 mois)
 **Mois 1-2 : Revue littérature approfondie**
 - [ ] Recherche bibliographique systématique
 - [ ] Analyse bibliométrique et mapping
 - [ ] Identification gaps de connaissance
 **Mois 3-4 : Design méthodologique**
 - [ ] Élaboration protocole expérimental
 - [ ] Validation instruments de mesure
 - [ ] Soumission comité d'éthique
 **Mois 5-6 : Préparation opérationnelle**
 - [ ] Formation équipe recherche
 - [ ] Tests pilotes et ajustements
 - [ ] Finalisation procédures
 ### Phase 2 - Collecte de données (12 mois)
 **Mois 7-12 : Collecte première vague**
 - [ ] Recrutement participants
 - [ ] Collecte données baseline
 - [ ] Monitoring qualité données
 **Mois 13-18 : Collecte follow-up**
 - [ ] Mesures longitudinales
 - [ ] Gestion attrition
 - [ ] Analyses intermédiaires
 ### Phase 3 - Analyse et interprétation (6 mois)
 **Mois 19-21 : Analyses principales**
 - [ ] Nettoyage et préparation données
 - [ ] Analyses statistiques planifiées
 - [ ] Analyses exploratoires
 **Mois 22-24 : Synthèse et rédaction**
 - [ ] Interprétation résultats
 - [ ] Discussion implications
 - [ ] Rédaction publications
 ### Phase 4 - Valorisation (6 mois)
 **Mois 25-27 : Publications scientifiques**
 - [ ] Rédaction articles peer-review
 - [ ] Soumission revues internationales
 - [ ] Réponses aux reviewers
 **Mois 28-30 : Diffusion et transfert**
 - [ ] Communications congrès
 - [ ] Rapport technique final
 - [ ] Transfert vers applications
 ## 10. Gestion de projet (Recherche collaborative)
 **Approche collaborative :**
 - Consortium multidisciplinaire
 - Réunions régulières équipe
 - Advisory board externe
 - Partenaires industriels/institutionnels
 **Governance scientifique :**
 - Comité de pilotage
 - Data Safety Monitoring Board
 - Publication policy
 - IP management
 **Indicateurs de progression :**
 - Milestones scientifiques atteints
 - Publications soumises/acceptées
 - Présentations congrès
 - Citations et impact
 **Risk management :**
 - Risques scientifiques (hypothèses non validées)
 - Risques opérationnels (recrutement, rétention)
 - Risques financiers (coûts, budgets)
 - Plans de contingence et alternatives
 ## 11. Conclusion
 **Contributions scientifiques attendues :**
 [Résumer l'avancement des connaissances, les innovations méthodologiques et l'impact scientifique]
 **Impact et applications :**
 [Retombées académiques, industrielles, sociétales]
 **Perspectives de recherche :**
 - [ ] Extensions méthodologiques
 - [ ] Nouvelles hypothèses à tester
 - [ ] Collaborations futures
 - [ ] Financements de suite
 **Dissémination et Open Science :**
 - [ ] Publications open access
 - [ ] Données FAIR et partageables
 - [ ] Code et méthodes reproductibles
 - [ ] Formations et capacity building
 ## 12. Annexes
 ### Annexe A - Protocole expérimental détaillé
 [Procédures step-by-step, check-lists, forms]
 ### Annexe B - Instruments de mesure
 [Questionnaires validés, échelles, grilles observation]
 ### Annexe C - Plan d'analyse statistique
 [Tests planifiés, assumptions, power analysis]
 ### Annexe D - Considérations éthiques
 [Approbation comité, consentements, procédures]
 ### Annexe E - Budget détaillé
 [Personnel, équipement, travel, other costs]
 ### Annexe F - Timeline avec milestones
 [Gantt chart, deliverables, dependencies]
 ---
 *Journal créé le : [DATE]*
 *Dernière mise à jour : [DATE]*
 *Statut éthique : [Approuvé/En cours/Exempt]*
 *Financement : [Source, montant, période]*
--- a/templates/recherche/detaille.md
+++ b/templates/recherche/detaille.md
@ -1,197 +0,0 @@
 # Projet de Recherche - Documentation Détaillée
 ## 1. Introduction et Contexte
 ### 1.1 Contexte général
 [Description du domaine de recherche et du contexte académique/industriel]
 ### 1.2 Problématique
 [Énoncé précis du problème de recherche]
 ### 1.3 Motivations
 [Pourquoi cette recherche est-elle importante ?]
 ### 1.4 Objectifs
 - **Objectif principal** :
 - **Objectifs secondaires** :
  -
  -
  -
 ### 1.5 Contributions attendues
 [En quoi cette recherche apportera-t-elle du nouveau ?]
 ## 2. État de l'art et Positionnement
 ### 2.1 Revue de littérature
 [Analyse détaillée des travaux existants]
 ### 2.2 Taxonomie des approches
 [Classification des méthodes existantes]
 ### 2.3 Analyse critique
 #### Forces des approches existantes
 -
 -
 #### Limitations identifiées
 -
 -
 ### 2.4 Positionnement de notre approche
 [Comment notre travail se situe par rapport à l'existant]
 ## 3. Méthodologie de Recherche
 ### 3.1 Cadre théorique
 [Fondements théoriques de l'approche]
 ### 3.2 Hypothèses de recherche
 - H1 :
 - H2 :
 - H3 :
 ### 3.3 Méthode expérimentale
 #### Design expérimental
 [Description du protocole]
 #### Variables étudiées
 - Variables indépendantes :
 - Variables dépendantes :
 - Variables de contrôle :
 ### 3.4 Outils et technologies
 - **Outils de développement** :
 - **Outils d'analyse** :
 - **Plateformes de test** :
 ### 3.5 Jeux de données
 [Description des données utilisées]
 ## 4. Architecture et Conception
 ### 4.1 Vue d'ensemble
 [Schéma général de l'approche]
 ### 4.2 Composants principaux
 #### Composant 1 : [Nom]
 - **Fonction** :
 - **Entrées** :
 - **Sorties** :
 - **Algorithme** :
 #### Composant 2 : [Nom]
 - **Fonction** :
 - **Entrées** :
 - **Sorties** :
 - **Algorithme** :
 ### 4.3 Interfaces et flux de données
 [Description des interactions entre composants]
 ## 5. Planning Détaillé
 ### Phase 1 : Étude préliminaire (Durée : X semaines)
 - [ ] Revue exhaustive de littérature
 - [ ] Analyse des outils existants
 - [ ] Définition précise des spécifications
 - [ ] **Livrable** : Rapport d'état de l'art
 ### Phase 2 : Conception et prototypage (Durée : X semaines)
 - [ ] Conception architecturale
 - [ ] Développement du prototype
 - [ ] Tests unitaires
 - [ ] **Livrable** : Prototype fonctionnel
 ### Phase 3 : Développement (Durée : X semaines)
 - [ ] Implémentation complète
 - [ ] Tests d'intégration
 - [ ] Optimisation des performances
 - [ ] **Livrable** : Version beta
 ### Phase 4 : Validation et évaluation (Durée : X semaines)
 - [ ] Tests sur jeux de données réels
 - [ ] Évaluation comparative
 - [ ] Analyse des résultats
 - [ ] **Livrable** : Rapport d'évaluation
 ### Phase 5 : Finalisation (Durée : X semaines)
 - [ ] Rédaction finale
 - [ ] Préparation des publications
 - [ ] Documentation utilisateur
 - [ ] **Livrable** : Document final
 ## 6. Métriques et Évaluation
 ### 6.1 Critères de succès
 - **Critère 1** : [Métrique] > [Seuil]
 - **Critère 2** : [Métrique] < [Seuil]
 ### 6.2 Protocole d'évaluation
 [Description de la méthode d'évaluation]
 ### 6.3 Benchmarks
 [Comparaison avec les solutions existantes]
 ## 7. Gestion des Risques
 ### 7.1 Analyse des risques
 | Risque | Description | Impact | Probabilité | Score | Plan de mitigation |
 |--------|-------------|---------|-------------|-------|-------------------|
 | R1 | | Élevé | Moyenne | 6 | |
 | R2 | | Moyen | Faible | 3 | |
 | R3 | | Faible | Élevée | 3 | |
 ### 7.2 Plans de contingence
 - **Plan A** : [Si risque majeur]
 - **Plan B** : [Si retard significatif]
 ## 8. Ressources et Budget
 ### 8.1 Ressources humaines
 - **Chercheur principal** : [Temps alloué]
 - **Collaborateurs** : [Temps alloué]
 ### 8.2 Ressources matérielles
 - **Équipement** :
 - **Logiciels** :
 - **Infrastructure** :
 ### 8.3 Budget estimé
 [Si applicable]
 ## 9. Livrables et Publications
 ### 9.1 Livrables techniques
 - [ ] Code source documenté
 - [ ] Documentation technique
 - [ ] Guide d'utilisation
 - [ ] Jeux de test
 ### 9.2 Publications visées
 - [ ] Conférence internationale : [Nom]
 - [ ] Journal : [Nom]
 - [ ] Workshop : [Nom]
 ## 10. Journal de Bord
 ### [Date] - [Étape]
 [Description des activités et découvertes]
 ### [Date] - [Étape]
 [Description des activités et découvertes]
 ## 11. Références et Bibliographie
 [1] Auteur, A. (Année). Titre. *Journal*, Volume(Numéro), pages.
 [2] Auteur, B. (Année). *Titre du livre*. Éditeur.
 ## Annexes
 ### Annexe A : Données complémentaires
 ### Annexe B : Code source principal
 ### Annexe C : Résultats détaillés
--- a/templates/recherche/simple.md
+++ b/templates/recherche/simple.md
@ -1,95 +0,0 @@
 # Journal de Conception - Projet de Recherche
 ## 1. Introduction
 **Contexte du projet :**
 [Décrire brièvement le domaine de recherche et la problématique scientifique]
 **Idée principale :**
 [Résumer l'hypothèse de recherche et la méthodologie envisagée en une phrase]
 ## 2. Objectifs du projet
 **Objectifs principaux :**
 - [ ] Objectif scientifique
 - [ ] Objectif méthodologique
 - [ ] Objectif applicatif
 **Questions de recherche :**
 - Question principale à investiguer
 - Sous-questions spécifiques
 - Hypothèses à tester
 ## 3. Présentation et spécifications
 **Description détaillée :**
 [Expliquer le projet de recherche et ses enjeux scientifiques]
 **Cahier des charges :**
 - **Domaine** : [Champ disciplinaire]
 - **Méthodologie** : [Approche quantitative/qualitative]
 - **Contraintes** : [Éthique, ressources, temps]
 ## 4. Fonctionnalités attendues
 - [ ] **Revue littérature** : État de l'art et positionnement
 - [ ] **Méthodologie** : Design expérimental et protocoles
 - [ ] **Collecte données** : Instruments et procédures
 - [ ] **Analyse** : Méthodes statistiques et interprétation
 ## 5. Conception globale
 **Démarche scientifique :**
 ```
 Question → Hypothèses → Méthodologie → Données → Analyse → Conclusions
 ```
 **Architecture recherche :**
 - **Théorique** : Cadre conceptuel et modèles
 - **Empirique** : Expériences et observations
 - **Analytique** : Traitement et statistiques
 - **Synthèse** : Interprétation et implications
 ## 6. Problématiques et solutions
 | Défi recherche | Solution envisagée |
 |----------------|-------------------|
 | Accès aux données | Partenariats institutionnels |
 | Validité interne | Contrôles expérimentaux |
 | Généralisation | Échantillonnage représentatif |
 ## 7. Environnement et outils
 **Outils de recherche :**
 - Bibliographie : Zotero, Mendeley
 - Analyse : R, Python, SPSS
 - Rédaction : LaTeX, Word
 - Collaboration : Git, cloud storage
 **Ressources :**
 - Bases de données scientifiques
 - Équipements de laboratoire
 - Financement recherche
 - Réseau collaboratif
 ## 8. Phases du projet
 **Phase 1 - Préparation (2 mois) :**
 - [ ] Revue littérature approfondie
 - [ ] Design méthodologique
 - [ ] Validation éthique
 **Phase 2 - Collecte (4 mois) :**
 - [ ] Recrutement participants
 - [ ] Collecte données
 - [ ] Monitoring qualité
 **Phase 3 - Analyse (3 mois) :**
 - [ ] Traitement statistique
 - [ ] Interprétation résultats
 - [ ] Rédaction publication
 ## 9. Conclusion
 **État d'avancement :**
 [À compléter au fur et à mesure]
 **Prochaines étapes :**
 - [ ] Finalisation protocole expérimental
 - [ ] Soumission comité éthique
 - [ ] Début collecte données
 ---
 *Journal créé le : [DATE]*
 *Dernière mise à jour : [DATE]*
--- a/views/header.js
+++ b/views/header.js
@ -2,7 +2,7 @@ function getHeader() {
  return `
  <header>
    <div>
-      <h1>Mon Journal de Conception</h1>
+      <h1>Design Journal</h1>
    </div>
  </header>
  `;
@ -15,35 +15,16 @@ function getLeftPanel() {
      <span class="arrow">▶</span>
    </div>
    <div class="panel-content">
-      <h3 class="panel-header">Templates de Projet</h3>
+      <h3 class="panel-header">New Document</h3>
      <div class="template-form">
        <div class="form-group">
-          <label for="domain-select">Domaine :</label>
+          <p style="margin-bottom: 1rem; color: var(--text-light);">Start with a default template for your design journal.</p>
          <select id="domain-select" title="Choisir le domaine">
            <option value="">-- Sélectionner un domaine --</option>
            <option value="recherche">Recherche</option>
            <option value="math">Mathématiques</option>
            <option value="informatique">Informatique</option>
            <option value="ingenierie">Ingénierie</option>
            <option value="business">Business</option>
            <option value="design">Design</option>
          </select>
        </div>
        <div class="form-group">
          <label for="level-select">Niveau de détail :</label>
          <select id="level-select" title="Niveau de détail" disabled>
            <option value="">-- Choisir d'abord un domaine --</option>
            <option value="simple">Simple</option>
            <option value="detaille">Détaillé</option>
            <option value="complet">Complet</option>
          </select>
        </div>
        <div class="form-actions">
-          <button id="load-template" class="btn success" title="Charger le template" disabled>
+          <button id="load-template" class="btn success" title="Load default template">
-            Charger le template
+            Load Default Template
          </button>
        </div>
      </div>
@ -59,14 +40,14 @@ function getRightPanel() {
      <span class="arrow">◀</span>
    </div>
    <div class="panel-content">
-      <h3 class="panel-header">Outils</h3>
+      <h3 class="panel-header">Tools</h3>
      <div class="nav-section">
-        <h4>Apparence</h4>
+        <h4>Appearance</h4>
        <div class="nav-buttons">
-          <button class="nav-btn" id="theme-toggle" title="Basculer mode sombre">
+          <button class="nav-btn" id="theme-toggle" title="Toggle dark mode">
            <span class="icon">☽</span>
-            <span>Basculer le thème</span>
+            <span>Toggle Theme</span>
          </button>
        </div>
      </div>
@ -74,9 +55,9 @@ function getRightPanel() {
      <div class="nav-section">
        <h4>Export</h4>
        <div class="nav-buttons">
-          <button class="nav-btn" id="export-md" title="Exporter en Markdown">
+          <button class="nav-btn" id="export-md" title="Export as Markdown">
            <span class="icon">↓</span>
-            <span>Exporter en Markdown</span>
+            <span>Export as Markdown</span>
          </button>
        </div>
      </div>
@ -84,10 +65,10 @@ function getRightPanel() {
      <div class="nav-section">
        <h4>Import</h4>
        <div class="nav-buttons">
-          <label class="panel-file-input" for="import-md" title="Importer Markdown">
+          <label class="panel-file-input" for="import-md" title="Import Markdown">
            <input id="import-md" type="file" accept=".md" style="display:none;">
-            <span class="icon">⬆️</span>
+            <span class="icon">↑</span>
-            <span>Importer Markdown</span>
+            <span>Import Markdown</span>
          </label>
        </div>
      </div>
--- a/views/main.js
+++ b/views/main.js
@ -2,62 +2,62 @@ function getMain() {
  return `
  <main>
    <section id="table-of-contents">
-      <h2>📑 Table des matières</h2>
+      <h2>Table of Contents</h2>
      <nav id="toc-nav">
        <div class="toc-placeholder">
-          <p>La table des matières sera générée automatiquement à partir des titres de votre journal.</p>
+          <p>The table of contents will be automatically generated from your journal headings.</p>
-          <button id="refresh-toc" class="btn secondary">🔄 Actualiser</button>
+          <button id="refresh-toc" class="btn secondary">Refresh</button>
        </div>
      </nav>
    </section>
    <section id="design-journal">
-      <h2>📝 Journal de conception</h2>
+      <h2>Design Journal</h2>
      <div id="journal-controls" style="padding: 1rem; border-bottom: 1px solid var(--border-color); display: flex; gap: 1rem; align-items: center; justify-content: center;">
-        <button id="save-journal" class="btn success">💾 Sauvegarder</button>
+        <button id="save-journal" class="btn success">Save</button>
-        <button id="load-journal" class="btn">📂 Charger</button>
+        <button id="load-journal" class="btn">Load</button>
-        <button id="preview-toggle" class="btn primary">👁️ Visualiser</button>
+        <button id="preview-toggle" class="btn primary">Preview</button>
        <span id="save-status" class="text-light"></span>
      </div>
-      <!-- Modal de chargement des journaux -->
+      <!-- Journal loading modal -->
      <div id="journal-modal" class="modal-overlay" style="display: none;">
        <div class="modal-content">
          <div class="modal-header">
-            <h3>📂 Sélectionner un journal</h3>
+            <h3>Select a Journal</h3>
            <button class="modal-close" id="close-journal-modal">×</button>
          </div>
          <div class="modal-body" id="journal-modal-body">
-            <!-- Contenu dynamique -->
+            <!-- Dynamic content -->
          </div>
        </div>
      </div>
      <div id="journal-editor" contenteditable="true">
-        <!-- Zone d'écriture principale -->
+        <!-- Main editor area -->
      </div>
    </section>
    <section id="ai-assistant">
-      <h2>🤖 Assistant IA</h2>
+      <h2>AI Assistant</h2>
      <div class="ai-controls" style="padding: 1rem; border-bottom: 1px solid var(--border-color);">
        <div class="ai-actions" style="display: grid; grid-template-columns: 1fr 1fr; gap: 0.5rem; margin-bottom: 1rem;">
-          <button id="activate-rephrase" class="btn" title="Reformuler le texte sélectionné">
+          <button id="activate-rephrase" class="btn" title="Rephrase selected text">
-            ✨ Reformuler
+            Rephrase
          </button>
-          <button id="check-inconsistencies" class="btn" title="Vérifier les incohérences">
+          <button id="check-inconsistencies" class="btn" title="Check for inconsistencies">
-            🔍 Incohérences
+            Inconsistencies
          </button>
-          <button id="check-duplications" class="btn" title="Vérifier les doublons">
+          <button id="check-duplications" class="btn" title="Check for duplicates">
-            📋 Doublons
+            Duplicates
          </button>
-          <button id="give-advice" class="btn" title="Conseils d'amélioration">
+          <button id="give-advice" class="btn" title="Get improvement advice">
-            💡 Conseils
+            Advice
          </button>
        </div>
        <div class="liberty-mode" style="border-top: 1px solid var(--border-color); padding-top: 1rem;">
          <div style="display: grid; grid-template-columns: 1fr 1fr; gap: 0.5rem; margin-bottom: 0.5rem;">
            <div style="display: flex; align-items: center; gap: 0.25rem;">
-              <label for="liberty-repeat-count" style="font-size: 0.85rem; color: var(--text-light);">Itérations:</label>
+              <label for="liberty-repeat-count" style="font-size: 0.85rem; color: var(--text-light);">Iterations:</label>
              <select id="liberty-repeat-count" style="padding: 0.25rem; border: 1px solid var(--border-color); border-radius: 4px; background: var(--surface-color); color: var(--text-color); font-size: 0.85rem;">
                <option value="1">1</option>
                <option value="2">2</option>
@ -72,27 +72,27 @@ function getMain() {
              </select>
            </div>
            <div style="display: flex; align-items: center; gap: 0.25rem;">
-              <label for="liberty-precision" style="font-size: 0.85rem; color: var(--text-light);">Précision:</label>
+              <label for="liberty-precision" style="font-size: 0.85rem; color: var(--text-light);">Precision:</label>
              <select id="liberty-precision" style="padding: 0.25rem; border: 1px solid var(--border-color); border-radius: 4px; background: var(--surface-color); color: var(--text-color); font-size: 0.85rem;">
-                <option value="30">30% (Très créatif)</option>
+                <option value="30">30% (Very creative)</option>
-                <option value="50">50% (Équilibré)</option>
+                <option value="50">50% (Balanced)</option>
-                <option value="70" selected>70% (Conservateur)</option>
+                <option value="70" selected>70% (Conservative)</option>
-                <option value="90">90% (Très précis)</option>
+                <option value="90">90% (Very precise)</option>
              </select>
            </div>
          </div>
-          <button id="liberty-mode" class="btn" style="width: 100%;" title="Mode Liberté Total - Génération itérative en temps réel">
+          <button id="liberty-mode" class="btn" style="width: 100%;" title="Enhanced Mode - Iterative generation in real-time">
-            🚀 Mode Liberté Total
+            Enhanced Mode
          </button>
        </div>
      </div>
      <div id="ai-assistant-feedback" style="flex: 1; padding: 1rem; overflow-y: auto; min-height: 200px;">
        <div class="feedback-message" style="text-align: center; color: var(--text-light);">
-          <strong>🎯 Assistant IA prêt</strong><br>
+          <strong>AI Assistant Ready</strong><br>
-          Sélectionnez du texte dans l'éditeur et cliquez sur une action pour commencer.
+          Select text in the editor and click an action to begin.
          <div style="margin-top: 1rem; font-size: 0.85rem;">
            <div style="margin-bottom: 0.5rem;"><strong>Powered by Mistral AI</strong></div>
-            <div>Modèle: Mistral Large (multilingue)</div>
+            <div>Model: Mistral Large (multilingual)</div>
          </div>
        </div>
      </div>