Initial commit

2025-11-29 17:58:52 +08:00
commit eac17f89fa
40 changed files with 4048 additions and 0 deletions
--- a/.claude-plugin/plugin.json
+++ b/.claude-plugin/plugin.json
@@ -0,0 +1,12 @@
+{
+  "name": "framework",
+  "description": "Plugin pour atournayre/framework avec commandes et intégrations",
+  "version": "1.0.0",
+  "author": {
+    "name": "Aurélien Tournayre",
+    "email": "aurelien.tournayre@gmail.com"
+  },
+  "skills": [
+    "./skills"
+  ]
+}
--- a/README.md
+++ b/README.md
@@ -0,0 +1,3 @@
+# framework
+
+Plugin pour atournayre/framework avec commandes et intégrations
--- a/plugin.lock.json
+++ b/plugin.lock.json
@@ -0,0 +1,193 @@
+{
+  "$schema": "internal://schemas/plugin.lock.v1.json",
+  "pluginId": "gh:atournayre/claude-marketplace:framework",
+  "normalized": {
+    "repo": null,
+    "ref": "refs/tags/v20251128.0",
+    "commit": "cc79b16cece49758a37985f2926bf3305bb3b987",
+    "treeHash": "8e414effa99b116b6952629a2697a26291b9e09f48eb4ec1f378578b1a823be3",
+    "generatedAt": "2025-11-28T10:14:01.106931Z",
+    "toolVersion": "publish_plugins.py@0.2.0"
+  },
+  "origin": {
+    "remote": "git@github.com:zhongweili/42plugin-data.git",
+    "branch": "master",
+    "commit": "aa1497ed0949fd50e99e70d6324a29c5b34f9390",
+    "repoRoot": "/Users/zhongweili/projects/openmind/42plugin-data"
+  },
+  "manifest": {
+    "name": "framework",
+    "description": "Plugin pour atournayre/framework avec commandes et intégrations",
+    "version": "1.0.0"
+  },
+  "content": {
+    "files": [
+      {
+        "path": "README.md",
+        "sha256": "c81d4d93521b16f2bbf322413ca8ce8af64802b6adbeed3ce098cb067e662044"
+      },
+      {
+        "path": ".claude-plugin/plugin.json",
+        "sha256": "02c38379c0442351d5cbd6b2dfd743105f991d3e4af2ba5c724c16cefe0ad236"
+      },
+      {
+        "path": "skills/make-urls/README.md",
+        "sha256": "7dac36005d6a4ffb651f4bf3dc6bf96ae2c9e64c87f0f601c83fceb6adda0773"
+      },
+      {
+        "path": "skills/make-urls/SKILL.md",
+        "sha256": "c0b8375416853121e12994d8eadaa8462562e18f59a2a30e66963308e54429d5"
+      },
+      {
+        "path": "skills/make-urls/templates/MessageHandler/UtilisateurUrlsMessageHandler.php",
+        "sha256": "7d8e2c3ce5c0d4c92b8bb857922b3233ca40dbd5be721ac74e6a1b7a022ec273"
+      },
+      {
+        "path": "skills/make-urls/templates/MessageHandler/UtilisateurUrlsMessage.php",
+        "sha256": "a45c8716a38371a6a152b7bf79f89cbe5660a63d2c0387ff844e30650f758559"
+      },
+      {
+        "path": "skills/make-urls/templates/Urls/UtilisateurUrls.php",
+        "sha256": "786dfd7d90d79102c8d58b8fc6d25a4d67387941680c9fe615969291e0a1bd57"
+      },
+      {
+        "path": "skills/make-entity/README.md",
+        "sha256": "7e8b2b898fa045a425e70879e09eb381967141adada567435a128b1fce6f9f0a"
+      },
+      {
+        "path": "skills/make-entity/SKILL.md",
+        "sha256": "1526a6cd6500f9c176c7c9035d9d708616e79b67a3c2fd64ef77771316a49ac8"
+      },
+      {
+        "path": "skills/make-entity/templates/Repository/UtilisateurRepositoryInterface.php",
+        "sha256": "40d3b44c07a6d8b1064edf6770d5a3300619c0ab2ea5055155877d3135f710a8"
+      },
+      {
+        "path": "skills/make-entity/templates/Repository/UtilisateurRepository.php",
+        "sha256": "5235da516cbb958e93836feade807fdb43f36fd6bb528c4d4bf542f98c8c4805"
+      },
+      {
+        "path": "skills/make-entity/templates/Entity/Utilisateur.php",
+        "sha256": "02b52ed35279f1eefbfd46245c26796e0be954197801b1340d787b5837afb13a"
+      },
+      {
+        "path": "skills/make-contracts/README.md",
+        "sha256": "0c9503a709718effc61015620abfac908520f98bebca3836838b99bea4512787"
+      },
+      {
+        "path": "skills/make-contracts/SKILL.md",
+        "sha256": "9ad070e55b24cf672d8b2512e0246f5cadc5df4b41fa0ae314deef912ad9ded4"
+      },
+      {
+        "path": "skills/make-contracts/templates/Contracts/OutInterface.php",
+        "sha256": "a5a4b73c5978168f2a56fc857c1e9145bf4d6d22f6181719d87d416d2a3ae480"
+      },
+      {
+        "path": "skills/make-contracts/templates/Contracts/HasUrlsInterface.php",
+        "sha256": "26aca7de55a3caf234ff7f748cc6ace7ec0cb937657f3af67b68773c4d635115"
+      },
+      {
+        "path": "skills/make-contracts/templates/Contracts/UrlsDataInterface.php",
+        "sha256": "533abfbb7abbe30ea037a1966b2bd2ba2efcbca041013799caceba7c17367cbf"
+      },
+      {
+        "path": "skills/make-contracts/templates/Contracts/InvalideDataInterface.php",
+        "sha256": "cd284a22f72e6e410b7462de52487cecbe3842d08f971b4dd62832345300d2b7"
+      },
+      {
+        "path": "skills/make-contracts/templates/Contracts/OutDataInterface.php",
+        "sha256": "fbb2d3e219243201ea00b6a1cb2e2d3c127829ecf64dbc7c0b2347dda4109679"
+      },
+      {
+        "path": "skills/make-contracts/templates/Contracts/InvalideInterface.php",
+        "sha256": "48ddb50e0c1a23ef93f2ea5793878f6bfd87727f413769e37df46229d37700a7"
+      },
+      {
+        "path": "skills/make-contracts/templates/Contracts/Doctrine/DoctrineMigrationInterface.php",
+        "sha256": "508aa5b0c26ab241abdf715d270df7b9da10ec06a95dd39303ce9c125b1f4962"
+      },
+      {
+        "path": "skills/make-contracts/templates/Contracts/Story/StoryInterface.php",
+        "sha256": "6b7d8cd6fe341a52e07796617def4db72d4b54df8df82a1ff50574421d0ceb95"
+      },
+      {
+        "path": "skills/make-out/README.md",
+        "sha256": "e4b1b6b62cea8c4c26f4920d4d30a0e29ea5c296eabfd0229e7d9b92144ff18d"
+      },
+      {
+        "path": "skills/make-out/SKILL.md",
+        "sha256": "c8f759d5e496c88806305b054113f1e42974bce06b088b4b56801b2a14d9a9d4"
+      },
+      {
+        "path": "skills/make-out/templates/Out/UtilisateurOut.php",
+        "sha256": "e5a82265834e301de7f163407215789914e14ac72878198ed19d28890bdd4e6e"
+      },
+      {
+        "path": "skills/make-invalide/README.md",
+        "sha256": "3ec4caf68128a722857a4166be4caf6bff1dc7980d2f5e0c15d8dd1bb53bb56e"
+      },
+      {
+        "path": "skills/make-invalide/SKILL.md",
+        "sha256": "725666ddd9b829608f5d41ae4dbe641da4beb1f9b2bed32fde08cc899a617224"
+      },
+      {
+        "path": "skills/make-invalide/templates/Invalide/UtilisateurInvalide.php",
+        "sha256": "3fea86c0007e2ac53d9582a1fffd31ccc43f54d42d8ee384edd1ea95404c2f9e"
+      },
+      {
+        "path": "skills/make-story/README.md",
+        "sha256": "d48c7051af564de41571fc7184c4d32144b2fcb2c9552062d07db78b7fe9827e"
+      },
+      {
+        "path": "skills/make-story/SKILL.md",
+        "sha256": "97194fe8ae895ad13dd1d46531174b26b4b5b9f07d1f18360e0491f3bb742d65"
+      },
+      {
+        "path": "skills/make-story/templates/Story/UtilisateurStory.php",
+        "sha256": "2f7078db14764b3caa3046448ffdf2bfe5f8a51e0817dab476a85e6495d8b66b"
+      },
+      {
+        "path": "skills/make-story/templates/Story/AppStory.php",
+        "sha256": "2141beb4b0657a7a3ef0925311e8801f33e2d6a891e4505f01e9d0a68c060f2e"
+      },
+      {
+        "path": "skills/make-all/README.md",
+        "sha256": "2f8baedb0c5e2ccb7de7244cc2a346800d5d1cc8a807c015ea23fcc31e0d7b00"
+      },
+      {
+        "path": "skills/make-all/SKILL.md",
+        "sha256": "6e3b3fe815ccec8fa69f9ab16e8c98f5908309d8c5350cabbee9dd21077cc863"
+      },
+      {
+        "path": "skills/make-collection/README.md",
+        "sha256": "906fbcb32c4018d9105f2fe3c043d9c0758e97e25b5890953fb2690c8498ad61"
+      },
+      {
+        "path": "skills/make-collection/SKILL.md",
+        "sha256": "a6cf7028a1022c748c240766cef1e36d11a93769a52fa84169087d55e47247be"
+      },
+      {
+        "path": "skills/make-collection/templates/Collection/UtilisateurCollection.php",
+        "sha256": "114ce58b7f1b1665902d7f9312a6df67390306a2be0d502d9df28ab1508bcb74"
+      },
+      {
+        "path": "skills/make-factory/README.md",
+        "sha256": "5973f214706811bb83acb31851e6a83c3f6c183795a50680e30a8229e705533b"
+      },
+      {
+        "path": "skills/make-factory/SKILL.md",
+        "sha256": "dd2e502de98b7ccc75a4e027e84ba147cbd96bcf6f6ce6838a5a3b5cf2e1fc40"
+      },
+      {
+        "path": "skills/make-factory/templates/Factory/UtilisateurFactory.php",
+        "sha256": "95a85202d958c1a303ba722ab06c541668cf905084c7e4a9e1a13061c7942c89"
+      }
+    ],
+    "dirSha256": "8e414effa99b116b6952629a2697a26291b9e09f48eb4ec1f378578b1a823be3"
+  },
+  "security": {
+    "scannedAt": null,
+    "scannerVersion": null,
+    "flags": []
+  }
+}
--- a/skills/make-all/README.md
+++ b/skills/make-all/README.md
@@ -0,0 +1,258 @@
+# Framework Make All
+
+Orchestrateur générant une stack complète pour une entité.
+
+## Vue d'ensemble
+Cette skill orchestre l'appel de toutes les skills du framework pour générer une entité complète avec tous ses composants selon les principes Elegant Objects et DDD.
+
+## Caractéristiques
+
+### Stack complète générée
+- **Contracts** - Interfaces de base (si absentes)
+- **Entity** - Entité Doctrine + Repository
+- **Out** - DTO immuable pour output
+- **Invalide** - Exceptions métier
+- **Urls** - Génération d'URLs + CQRS
+- **Collection** - Collection typée
+- **Factory** - Factory Foundry pour tests
+- **Story** - Story Foundry pour fixtures
+
+## Utilisation
+
+```bash
+Use skill framework:make:all
+```
+
+Vous serez invité à fournir :
+1. Nom de l'entité
+2. Propriétés avec types (optionnel)
+
+## Exemple d'utilisation
+
+```bash
+EntityName: Product
+Properties:
+  - name: string
+  - description: string
+  - price: float
+  - stock: int
+  - isActive: bool
+```
+
+Génère 15+ fichiers en une seule commande.
+
+## Ordre d'exécution
+
+### Phase 1 - Fondation
+```
+framework:make:contracts (si besoin)
+```
+
+### Phase 2 - Core
+```
+framework:make:entity
+```
+
+### Phase 3 - Patterns
+```
+framework:make:out
+framework:make:invalide
+```
+
+### Phase 4 - Avancé
+```
+framework:make:urls
+framework:make:collection
+```
+
+### Phase 5 - Tests
+```
+framework:make:factory
+framework:make:story
+```
+
+## Fichiers générés
+
+### Contracts (si absents)
+```
+src/Contracts/
+├── OutInterface.php
+├── InvalideInterface.php
+├── HasUrlsInterface.php
+├── OutDataInterface.php
+├── InvalideDataInterface.php
+├── UrlsDataInterface.php
+├── Story/
+│   └── StoryInterface.php
+└── Doctrine/
+    └── DoctrineMigrationInterface.php
+```
+
+### Core
+```
+src/
+├── Entity/
+│   └── Product.php
+└── Repository/
+    ├── ProductRepository.php
+    └── ProductRepositoryInterface.php
+```
+
+### Patterns
+```
+src/
+├── Out/
+│   └── ProductOut.php
+└── Invalide/
+    └── ProductInvalide.php
+```
+
+### Avancé
+```
+src/
+├── Urls/
+│   └── ProductUrls.php
+├── MessageHandler/
+│   ├── ProductUrlsMessage.php
+│   └── ProductUrlsMessageHandler.php
+└── Collection/
+    └── ProductCollection.php
+```
+
+### Tests
+```
+src/
+├── Factory/
+│   └── ProductFactory.php
+└── Story/
+    ├── ProductStory.php
+    └── AppStory.php (updated)
+```
+
+## Output exemple
+
+```
+✓ Phase 1 - Fondation
+  ✓ Contracts déjà présents
+
+✓ Phase 2 - Core
+  ✓ src/Entity/Product.php
+  ✓ src/Repository/ProductRepository.php
+  ✓ src/Repository/ProductRepositoryInterface.php
+
+✓ Phase 3 - Patterns
+  ✓ src/Out/ProductOut.php
+  ✓ src/Invalide/ProductInvalide.php
+
+✓ Phase 4 - Avancé
+  ✓ src/Urls/ProductUrls.php
+  ✓ src/MessageHandler/ProductUrlsMessage.php
+  ✓ src/MessageHandler/ProductUrlsMessageHandler.php
+  ✓ src/Collection/ProductCollection.php
+
+✓ Phase 5 - Tests
+  ✓ src/Factory/ProductFactory.php
+  ✓ src/Story/ProductStory.php
+  ✓ src/Story/AppStory.php (updated)
+
+📊 Total: 15 fichiers créés
+```
+
+## Prochaines étapes
+
+Après génération, suivre ces étapes :
+
+1. **Migration Doctrine**
+```bash
+php bin/console make:migration
+php bin/console doctrine:migrations:migrate
+```
+
+2. **Enrichir les classes**
+- ProductInvalide : ajouter exceptions métier
+- ProductUrls : ajouter méthodes d'URLs
+- ProductOut : ajouter propriétés exposées
+- ProductCollection : ajouter méthodes métier (YAGNI)
+- ProductFactory : ajouter méthodes custom (YAGNI)
+- ProductStory : ajouter scénarios de test
+
+3. **Tests**
+```bash
+php bin/phpunit
+```
+
+4. **Validation PHPStan**
+```bash
+vendor/bin/phpstan analyse
+```
+
+## Prérequis
+
+- Framework `atournayre/framework` installé avec ses dépendances
+- Projet Symfony avec Doctrine ORM configuré
+- Zenstruck Foundry pour les tests (optionnel)
+
+## Avantages
+
+### Rapidité
+- Une seule commande pour générer toute la stack
+- Pas besoin d'appeler 8 skills manuellement
+- Gain de temps considérable
+
+### Cohérence
+- Ordre d'exécution garanti
+- Dépendances gérées automatiquement
+- Pas de risque d'oublier un composant
+
+### Best practices
+- Principes Elegant Objects appliqués partout
+- DDD respecté
+- Architecture cohérente
+
+## Cas d'usage
+
+### Nouveau projet
+```bash
+# Créer première entité complète
+Use skill framework:make:all
+EntityName: User
+```
+
+### Ajout feature
+```bash
+# Ajouter nouvelle entité au projet existant
+Use skill framework:make:all
+EntityName: Order
+```
+
+### Prototypage rapide
+```bash
+# Générer rapidement plusieurs entités
+Use skill framework:make:all (Product)
+Use skill framework:make:all (Category)
+Use skill framework:make:all (Review)
+```
+
+## Gestion d'erreurs
+
+Si une skill échoue :
+1. Affichage clair de l'erreur
+2. Indication de la skill en erreur
+3. Arrêt du processus
+4. Fichiers déjà créés conservés
+
+## Options futures
+
+Possibles extensions :
+- `--skip-tests` : sans Factory/Story
+- `--skip-urls` : sans Urls/CQRS
+- `--minimal` : Entity + Repository + Out uniquement
+- `--api-only` : Stack pour API (Entity + Repository + Out + Collection)
+
+## Principes Elegant Objects appliqués
+- Toutes les classes finales
+- Constructeurs privés
+- Factory statiques
+- Immutabilité encouragée
+- Interfaces pour tous les contrats
+- Tests first-class citizens
--- a/skills/make-all/SKILL.md
+++ b/skills/make-all/SKILL.md
@@ -0,0 +1,195 @@
+---
+name: framework:make:all
+description: Génère tous les fichiers pour une entité complète (orchestrateur)
+license: MIT
+version: 1.0.0
+---
+
+# Framework Make All Skill
+
+## Description
+Orchestrateur qui génère tous les fichiers nécessaires pour une entité complète en appelant séquentiellement toutes les skills du framework.
+
+Cette skill crée une stack complète respectant les principes Elegant Objects et DDD pour une entité donnée.
+
+## Usage
+```
+Use skill framework:make:all
+
+Vous serez invité à fournir :
+- Le nom de l'entité (ex: Product, User, Order)
+- Les propriétés avec leurs types (optionnel)
+```
+
+## Dépendances
+Cette skill orchestre l'appel de toutes les autres skills :
+1. `framework:make:contracts` (si pas déjà présents)
+2. `framework:make:entity`
+3. `framework:make:out`
+4. `framework:make:invalide`
+5. `framework:make:urls`
+6. `framework:make:collection`
+7. `framework:make:factory`
+8. `framework:make:story`
+
+## Variables requises
+- **{EntityName}** - Nom de l'entité en PascalCase (ex: Utilisateur, Product)
+- **{properties}** - Liste des propriétés avec types (optionnel, array)
+
+## Outputs
+Tous les fichiers générés par les 8 skills :
+
+**Contracts** (si non existants)
+- `src/Contracts/OutInterface.php`
+- `src/Contracts/InvalideInterface.php`
+- `src/Contracts/HasUrlsInterface.php`
+- `src/Contracts/OutDataInterface.php`
+- `src/Contracts/InvalideDataInterface.php`
+- `src/Contracts/UrlsDataInterface.php`
+- `src/Contracts/Story/StoryInterface.php`
+- `src/Contracts/Doctrine/DoctrineMigrationInterface.php`
+
+**Core**
+- `src/Entity/{EntityName}.php`
+- `src/Repository/{EntityName}Repository.php`
+- `src/Repository/{EntityName}RepositoryInterface.php`
+
+**Patterns**
+- `src/Out/{EntityName}Out.php`
+- `src/Invalide/{EntityName}Invalide.php`
+
+**Avancé**
+- `src/Urls/{EntityName}Urls.php`
+- `src/MessageHandler/{EntityName}UrlsMessage.php`
+- `src/MessageHandler/{EntityName}UrlsMessageHandler.php`
+- `src/Collection/{EntityName}Collection.php`
+
+**Tests**
+- `src/Factory/{EntityName}Factory.php`
+- `src/Story/{EntityName}Story.php`
+- `src/Story/AppStory.php` (updated)
+
+## Workflow
+
+1. Demander le nom de l'entité (EntityName)
+2. Demander les propriétés (optionnel)
+3. Vérifier si `src/Contracts/` existe
+   - Si non : exécuter `framework:make:contracts`
+4. Exécuter séquentiellement :
+   1. `framework:make:entity` (avec EntityName et properties)
+   2. `framework:make:out` (avec EntityName)
+   3. `framework:make:invalide` (avec EntityName)
+   4. `framework:make:urls` (avec EntityName)
+   5. `framework:make:collection` (avec EntityName)
+   6. `framework:make:factory` (avec EntityName et properties)
+   7. `framework:make:story` (avec EntityName)
+5. Afficher le résumé de tous les fichiers créés
+6. Afficher les prochaines étapes recommandées
+
+## Ordre d'exécution (critique)
+
+L'ordre d'appel des skills est important car il respecte les dépendances :
+
+```
+Phase 1 - Fondation
+└── make:contracts (si besoin)
+
+Phase 2 - Core
+└── make:entity (dépend de: contracts)
+
+Phase 3 - Patterns (parallélisables mais dépendent de entity)
+├── make:out (dépend de: entity)
+└── make:invalide (dépend de: entity)
+
+Phase 4 - Avancé (dépendent de entity + repository)
+├── make:urls (dépend de: entity, repository)
+└── make:collection (dépend de: entity)
+
+Phase 5 - Tests (dépendent de entity)
+├── make:factory (dépend de: entity)
+└── make:story (dépend de: entity, factory)
+```
+
+## Exemple
+
+```bash
+Use skill framework:make:all
+
+# Saisies utilisateur :
+EntityName: Product
+Properties:
+  - name: string
+  - description: string
+  - price: float
+  - stock: int
+  - isActive: bool
+
+# Résultat :
+✓ Phase 1 - Fondation
+  ✓ Contracts déjà présents
+
+✓ Phase 2 - Core
+  ✓ src/Entity/Product.php
+  ✓ src/Repository/ProductRepository.php
+  ✓ src/Repository/ProductRepositoryInterface.php
+
+✓ Phase 3 - Patterns
+  ✓ src/Out/ProductOut.php
+  ✓ src/Invalide/ProductInvalide.php
+
+✓ Phase 4 - Avancé
+  ✓ src/Urls/ProductUrls.php
+  ✓ src/MessageHandler/ProductUrlsMessage.php
+  ✓ src/MessageHandler/ProductUrlsMessageHandler.php
+  ✓ src/Collection/ProductCollection.php
+
+✓ Phase 5 - Tests
+  ✓ src/Factory/ProductFactory.php
+  ✓ src/Story/ProductStory.php
+  ✓ src/Story/AppStory.php (updated)
+
+📊 Total: 15 fichiers créés
+
+📝 Prochaines étapes recommandées:
+1. Créer la migration Doctrine: php bin/console make:migration
+2. Exécuter la migration: php bin/console doctrine:migrations:migrate
+3. Enrichir ProductInvalide avec exceptions métier
+4. Enrichir ProductUrls avec méthodes d'URLs
+5. Enrichir ProductOut avec propriétés exposées
+6. Enrichir ProductCollection avec méthodes métier (si besoin)
+7. Enrichir ProductFactory avec méthodes custom (si besoin)
+8. Enrichir ProductStory avec scénarios de test
+9. Lancer les tests: php bin/phpunit
+```
+
+## Validation après génération
+
+La skill doit vérifier que tous les fichiers ont été créés correctement :
+
+1. Vérifier existence de tous les fichiers
+2. Vérifier que les imports sont corrects
+3. Vérifier que les namespaces sont cohérents
+4. Vérifier que AppStory a été mis à jour
+
+## Gestion des erreurs
+
+Si une skill échoue :
+1. Afficher l'erreur clairement
+2. Indiquer quelle skill a échoué
+3. Proposer de corriger manuellement
+4. Ne pas continuer avec les skills suivantes si une skill critique échoue
+
+## Options avancées (futur)
+
+Potentiellement ajouter des flags :
+- `--skip-tests` : ne pas générer Factory et Story
+- `--skip-urls` : ne pas générer Urls + handlers
+- `--minimal` : générer uniquement Entity + Repository + Out
+- `--api-only` : générer pour API (Entity + Repository + Out + Collection)
+
+## Notes
+- Cette skill est un orchestrateur, elle ne contient pas de templates
+- Elle appelle séquentiellement toutes les autres skills
+- L'ordre d'exécution est critique et respecte les dépendances
+- Idéale pour démarrer rapidement avec une nouvelle entité
+- Génère une stack complète Elegant Objects + DDD
--- a/skills/make-collection/README.md
+++ b/skills/make-collection/README.md
@@ -0,0 +1,237 @@
+# Framework Make Collection
+
+Génère une classe Collection typée avec traits Atournayre.
+
+## Vue d'ensemble
+Cette skill crée une classe Collection type-safe pour gérer des ensembles d'entités selon les principes Elegant Objects.
+
+## Caractéristiques
+
+### Classe Collection générée
+- Classe `final`
+- Type-safe (collection d'objets typés)
+- Interfaces Atournayre complètes
+- Traits pour fonctionnalités de base
+- Factory statique `asList()`
+- Méthode `toLog()` pour logging
+
+## Utilisation
+
+```bash
+Use skill framework:make:collection
+```
+
+Vous serez invité à fournir le nom de l'entité.
+
+## Exemple d'utilisation
+
+```bash
+EntityName: Product
+```
+
+Génère :
+```php
+// src/Collection/ProductCollection.php
+final class ProductCollection implements AsListInterface, ToArrayInterface, CountInterface, ...
+{
+    use Collection;
+    use Collection\ToArray;
+    use Collection\Countable;
+
+    public static function asList(array $collection): self
+    {
+        return new self(PrimitiveCollection::of($collection));
+    }
+
+    public function toLog(): array
+    {
+        return [
+            'count' => $this->count()->value(),
+            'items' => $this->collection->map(fn (Product $item) => $item->toLog()),
+        ];
+    }
+}
+```
+
+## Structure créée
+
+```
+src/
+└── Collection/
+    └── {EntityName}Collection.php
+```
+
+## Prérequis
+- L'entité doit exister dans `src/Entity/{EntityName}.php`
+- Framework `atournayre/framework` installé
+
+## Interfaces implémentées
+
+- **AsListInterface** - Factory `asList()`
+- **ToArrayInterface** - Conversion en array
+- **CountInterface** - Comptage d'éléments
+- **CountByInterface** - Comptage conditionnel
+- **AtLeastOneElementInterface** - Vérification présence
+- **HasSeveralElementsInterface** - Vérification multiple
+- **HasNoElementInterface** - Vérification vide
+- **HasOneElementInterface** - Vérification unique
+- **HasXElementsInterface** - Vérification nombre exact
+- **LoggableInterface** - Support logging
+
+## Méthodes disponibles via traits
+
+```php
+// Création
+$products = ProductCollection::asList([$product1, $product2]);
+
+// Comptage
+$products->count(); // Number
+$products->hasNoElement(); // bool
+$products->hasOneElement(); // bool
+$products->hasSeveralElements(); // bool
+$products->hasAtLeastOneElement(); // bool
+$products->hasXElements(5); // bool
+
+// Comptage conditionnel
+$activeCount = $products->countBy(fn (Product $p) => $p->isActive());
+
+// Conversion
+$array = $products->toArray();
+
+// Logging
+$log = $products->toLog();
+```
+
+## Enrichissement (principe YAGNI)
+
+**IMPORTANT** : N'ajouter que les méthodes **explicitement demandées**.
+
+### Exemple : filtrage
+```php
+public function active(): self
+{
+    return new self(
+        $this->collection->filter(fn (Product $p) => $p->isActive())
+    );
+}
+
+public function inStock(): self
+{
+    return new self(
+        $this->collection->filter(fn (Product $p) => $p->stock() > 0)
+    );
+}
+```
+
+### Exemple : calculs
+```php
+public function totalPrice(): float
+{
+    return $this->collection
+        ->map(fn (Product $p) => $p->price())
+        ->reduce(fn (float $sum, float $price) => $sum + $price, 0.0);
+}
+
+public function averagePrice(): float
+{
+    if ($this->hasNoElement()) {
+        return 0.0;
+    }
+    return $this->totalPrice() / $this->count()->value();
+}
+```
+
+### Exemple : tri
+```php
+public function sortedByName(): self
+{
+    return new self(
+        $this->collection->sort(fn (Product $a, Product $b) =>
+            $a->name() <=> $b->name()
+        )
+    );
+}
+
+public function sortedByPriceDesc(): self
+{
+    return new self(
+        $this->collection->sort(fn (Product $a, Product $b) =>
+            $b->price() <=> $a->price()
+        )
+    );
+}
+```
+
+### Exemple : recherche
+```php
+public function findById(Uuid $id): ?Product
+{
+    return $this->collection
+        ->filter(fn (Product $p) => $p->id()->equals($id))
+        ->first();
+}
+
+public function findByName(string $name): self
+{
+    return new self(
+        $this->collection->filter(fn (Product $p) => $p->name() === $name)
+    );
+}
+```
+
+## Usage dans le code
+
+### Depuis un repository
+```php
+final class ProductRepository extends ServiceEntityRepository
+{
+    public function findAllAsCollection(): ProductCollection
+    {
+        return ProductCollection::asList($this->findAll());
+    }
+
+    public function findActiveAsCollection(): ProductCollection
+    {
+        return ProductCollection::asList(
+            $this->createQueryBuilder('p')
+                ->where('p.isActive = true')
+                ->getQuery()
+                ->getResult()
+        );
+    }
+}
+```
+
+### Dans un service
+```php
+final readonly class ProductService
+{
+    public function calculateTotalStock(ProductCollection $products): int
+    {
+        return $products->collection
+            ->map(fn (Product $p) => $p->stock())
+            ->reduce(fn (int $sum, int $stock) => $sum + $stock, 0);
+    }
+}
+```
+
+### Dans un contrôleur
+```php
+public function index(ProductRepository $repository): Response
+{
+    $products = $repository->findAllAsCollection();
+
+    return $this->render('product/index.html.twig', [
+        'products' => $products->active()->sortedByName(),
+        'total' => $products->count()->value(),
+    ]);
+}
+```
+
+## Principes Elegant Objects appliqués
+- Classe finale
+- Factory statique
+- Type-safety
+- Immutabilité (nouvelles instances pour transformations)
+- Pas de méthodes génériques anticipées (YAGNI)
+- LoggableInterface pour observabilité
--- a/skills/make-collection/SKILL.md
+++ b/skills/make-collection/SKILL.md
@@ -0,0 +1,192 @@
+---
+name: framework:make:collection
+description: Génère classe Collection typée avec traits Atournayre
+license: MIT
+version: 1.0.0
+---
+
+# Framework Make Collection Skill
+
+## Description
+Génère une classe Collection typée pour gérer des ensembles d'entités avec les traits et interfaces Atournayre.
+
+La Collection offre des méthodes pour manipuler des ensembles d'objets de manière type-safe et respectant les principes Elegant Objects.
+
+## Usage
+```
+Use skill framework:make:collection
+
+Vous serez invité à fournir :
+- Le nom de l'entité (ex: Product, User, Order)
+```
+
+## Templates
+- `Collection/UtilisateurCollection.php` - Template de classe Collection
+
+## Variables requises
+- **{EntityName}** - Nom de l'entité en PascalCase (ex: Utilisateur, Product)
+- **{entityName}** - Nom de l'entité en camelCase (ex: utilisateur, product)
+- **{namespace}** - Namespace du projet (défaut: App)
+
+## Dépendances
+- Requiert que l'entité existe dans `src/Entity/{EntityName}.php`
+- Requiert framework `atournayre/framework`
+
+## Outputs
+- `src/Collection/{EntityName}Collection.php`
+
+## Workflow
+
+1. Demander le nom de l'entité (EntityName)
+2. Vérifier que l'entité existe dans `src/Entity/{EntityName}.php`
+   - Si non : arrêter et demander de créer l'entité d'abord
+3. Générer la classe Collection depuis le template :
+   - Remplacer `{EntityName}` par le nom fourni
+   - Remplacer `{entityName}` par la version camelCase
+4. Afficher le fichier créé
+
+## Patterns appliqués
+
+### Classe Collection
+- Classe `final`
+- Implémente interfaces Atournayre :
+  - AsListInterface
+  - ToArrayInterface
+  - CountInterface
+  - CountByInterface
+  - AtLeastOneElementInterface
+  - HasSeveralElementsInterface
+  - HasNoElementInterface
+  - HasOneElementInterface
+  - HasXElementsInterface
+  - LoggableInterface
+- Utilise traits Atournayre :
+  - Collection
+  - Collection\ToArray
+  - Collection\Countable
+- Méthode statique `asList(array $collection)`
+- Méthode `toLog()` pour logging
+
+## Exemple
+
+```bash
+Use skill framework:make:collection
+
+# Saisies utilisateur :
+EntityName: Product
+
+# Résultat :
+✓ src/Collection/ProductCollection.php
+```
+
+Fichier généré :
+```php
+<?php
+
+declare(strict_types=1);
+
+namespace App\Collection;
+
+use App\Entity\Product;
+use Atournayre\Contracts\Collection\AsListInterface;
+use Atournayre\Contracts\Collection\AtLeastOneElementInterface;
+use Atournayre\Contracts\Collection\CountByInterface;
+use Atournayre\Contracts\Collection\CountInterface;
+use Atournayre\Contracts\Collection\HasNoElementInterface;
+use Atournayre\Contracts\Collection\HasOneElementInterface;
+use Atournayre\Contracts\Collection\HasSeveralElementsInterface;
+use Atournayre\Contracts\Collection\HasXElementsInterface;
+use Atournayre\Contracts\Collection\ToArrayInterface;
+use Atournayre\Contracts\Log\LoggableInterface;
+use Atournayre\Primitives\Collection as PrimitiveCollection;
+use Atournayre\Primitives\Traits\Collection;
+
+final class ProductCollection implements AsListInterface, ToArrayInterface, CountInterface, CountByInterface, AtLeastOneElementInterface, HasSeveralElementsInterface, HasNoElementInterface, HasOneElementInterface, HasXElementsInterface, LoggableInterface
+{
+    use Collection;
+    use Collection\ToArray;
+    use Collection\Countable;
+
+    public static function asList(array $collection): self
+    {
+        return new self(PrimitiveCollection::of($collection));
+    }
+
+    /**
+     * @return array<string, mixed>
+     */
+    public function toLog(): array
+    {
+        return [
+            'count' => $this->count()->value(),
+            'items' => $this->collection->map(fn (Product $item) => $item->toLog()),
+        ];
+    }
+
+    // UNIQUEMENT les méthodes EXPLICITEMENT demandées par l'utilisateur
+    // PAS d'anticipation de besoins futurs
+    // PAS de méthodes génériques (add, remove, filter, map, etc.)
+}
+```
+
+## Usage
+
+### Création d'une collection
+
+```php
+$products = ProductCollection::asList([
+    $product1,
+    $product2,
+    $product3,
+]);
+```
+
+### Méthodes disponibles (via traits)
+
+```php
+// Comptage
+$count = $products->count(); // Atournayre\Primitives\Number
+$hasElements = $products->hasNoElement(); // bool
+$hasOne = $products->hasOneElement(); // bool
+$hasSeveral = $products->hasSeveralElements(); // bool
+$hasAtLeastOne = $products->hasAtLeastOneElement(); // bool
+$hasX = $products->hasXElements(5); // bool
+
+// Conversion
+$array = $products->toArray(); // array
+
+// Comptage personnalisé
+$activeCount = $products->countBy(fn (Product $p) => $p->isActive());
+```
+
+### Ajout de méthodes métier (YAGNI)
+
+N'ajouter que les méthodes **explicitement demandées** :
+
+```php
+final class ProductCollection implements ...
+{
+    // ... traits ...
+
+    public function active(): self
+    {
+        return new self(
+            $this->collection->filter(fn (Product $p) => $p->isActive())
+        );
+    }
+
+    public function totalPrice(): float
+    {
+        return $this->collection
+            ->map(fn (Product $p) => $p->price())
+            ->reduce(fn (float $sum, float $price) => $sum + $price, 0.0);
+    }
+}
+```
+
+## Notes
+- Respect du principe YAGNI : pas de méthodes génériques anticipées
+- Seules les méthodes explicitement demandées doivent être ajoutées
+- Les traits fournissent déjà beaucoup de fonctionnalités
+- La collection est type-safe (typage sur l'entité)
+- LoggableInterface permet le logging automatique
--- a/skills/make-collection/templates/Collection/UtilisateurCollection.php
+++ b/skills/make-collection/templates/Collection/UtilisateurCollection.php
@@ -0,0 +1,46 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Collection;
+
+use App\Entity\Utilisateur;
+use Atournayre\Contracts\Collection\AsListInterface;
+use Atournayre\Contracts\Collection\AtLeastOneElementInterface;
+use Atournayre\Contracts\Collection\CountByInterface;
+use Atournayre\Contracts\Collection\CountInterface;
+use Atournayre\Contracts\Collection\HasNoElementInterface;
+use Atournayre\Contracts\Collection\HasOneElementInterface;
+use Atournayre\Contracts\Collection\HasSeveralElementsInterface;
+use Atournayre\Contracts\Collection\HasXElementsInterface;
+use Atournayre\Contracts\Collection\ToArrayInterface;
+use Atournayre\Contracts\Log\LoggableInterface;
+use Atournayre\Primitives\Collection as PrimitiveCollection;
+use Atournayre\Primitives\Traits\Collection;
+
+final class UtilisateurCollection implements AsListInterface, ToArrayInterface, CountInterface, CountByInterface, AtLeastOneElementInterface, HasSeveralElementsInterface, HasNoElementInterface, HasOneElementInterface, HasXElementsInterface, LoggableInterface
+{
+    use Collection;
+    use Collection\ToArray;
+    use Collection\Countable;
+
+    public static function asList(array $collection): self
+    {
+        return new self(PrimitiveCollection::of($collection));
+    }
+
+    /**
+     * @return array<string, mixed>
+     */
+    public function toLog(): array
+    {
+        return [
+            'count' => $this->count()->value(),
+            'items' => $this->collection->map(fn (Utilisateur $item) => $item->toLog()),
+        ];
+    }
+
+    // UNIQUEMENT les méthodes EXPLICITEMENT demandées par l'utilisateur
+    // PAS d'anticipation de besoins futurs
+    // PAS de méthodes génériques (add, remove, filter, map, etc.)
+}
--- a/skills/make-contracts/README.md
+++ b/skills/make-contracts/README.md
@@ -0,0 +1,55 @@
+# Framework Make Contracts
+
+Génère les interfaces de contrats pour une architecture Elegant Objects.
+
+## Vue d'ensemble
+Cette skill crée l'ensemble des interfaces nécessaires pour supporter les principes Elegant Objects et DDD dans un projet Symfony.
+
+## Interfaces générées
+
+### Interfaces principales
+- **OutInterface** - Pour objets de sortie (DTO immuables)
+- **InvalideInterface** - Pour exceptions métier
+- **HasUrlsInterface** - Pour objets ayant des URLs générées
+
+### Interfaces de data
+- **OutDataInterface** - Pour data classes de sortie
+- **InvalideDataInterface** - Pour data classes d'invalidation
+- **UrlsDataInterface** - Pour data classes d'URLs
+
+### Interfaces spécialisées
+- **StoryInterface** - Pour stories de tests (Foundry)
+- **DoctrineMigrationInterface** - Pour migrations Doctrine
+
+## Utilisation
+
+```bash
+# Via skill
+Use skill framework:make:contracts
+```
+
+## Structure créée
+
+```
+src/
+└── Contracts/
+    ├── OutInterface.php
+    ├── InvalideInterface.php
+    ├── HasUrlsInterface.php
+    ├── OutDataInterface.php
+    ├── InvalideDataInterface.php
+    ├── UrlsDataInterface.php
+    ├── Story/
+    │   └── StoryInterface.php
+    └── Doctrine/
+        └── DoctrineMigrationInterface.php
+```
+
+## Prérequis
+Aucun - C'est la première skill à exécuter dans un nouveau projet.
+
+## Principes Elegant Objects appliqués
+- Toutes les interfaces définissent des contrats clairs
+- Pas de méthodes statiques
+- Chaque interface a une responsabilité unique
+- Favorise l'immutabilité et l'encapsulation
--- a/skills/make-contracts/SKILL.md
+++ b/skills/make-contracts/SKILL.md
@@ -0,0 +1,59 @@
+---
+name: framework:make:contracts
+description: Génère les interfaces de contrats pour une architecture Elegant Objects
+license: MIT
+version: 1.0.0
+---
+
+# Framework Make Contracts Skill
+
+## Description
+Génère l'ensemble des interfaces de contrats nécessaires pour une architecture respectant les principes Elegant Objects et DDD.
+
+Ces interfaces servent de fondation pour toutes les autres skills du framework.
+
+## Usage
+```
+Use skill framework:make:contracts
+```
+
+## Templates
+- `OutInterface.php` - Interface pour objets de sortie (DTO)
+- `InvalideInterface.php` - Interface pour exceptions métier
+- `HasUrlsInterface.php` - Interface pour objets ayant des URLs
+- `OutDataInterface.php` - Interface pour data classes de sortie
+- `InvalideDataInterface.php` - Interface pour data classes d'invalidation
+- `UrlsDataInterface.php` - Interface pour data classes d'URLs
+- `Story/StoryInterface.php` - Interface pour stories de tests
+- `Doctrine/DoctrineMigrationInterface.php` - Interface pour migrations Doctrine
+
+## Variables requises
+Aucune - Ces interfaces sont génériques et ne nécessitent pas de paramètres.
+
+## Dépendances
+Aucune - C'est la première skill à exécuter (Niveau 0 - Fondation).
+
+## Outputs
+- `src/Contracts/OutInterface.php`
+- `src/Contracts/InvalideInterface.php`
+- `src/Contracts/HasUrlsInterface.php`
+- `src/Contracts/OutDataInterface.php`
+- `src/Contracts/InvalideDataInterface.php`
+- `src/Contracts/UrlsDataInterface.php`
+- `src/Contracts/Story/StoryInterface.php`
+- `src/Contracts/Doctrine/DoctrineMigrationInterface.php`
+
+## Workflow
+
+1. Vérifier si le répertoire `src/Contracts/` existe
+2. Créer la structure de répertoires si nécessaire :
+   - `src/Contracts/`
+   - `src/Contracts/Story/`
+   - `src/Contracts/Doctrine/`
+3. Copier tous les templates d'interfaces depuis `framework/skills/make-contracts/templates/Contracts/` vers `src/Contracts/`
+4. Afficher la liste des fichiers créés
+
+## Notes
+- Ces interfaces n'ont pas besoin d'être modifiées pour chaque projet
+- Elles doivent être créées une seule fois par projet
+- Toutes les autres skills du framework dépendent de ces interfaces
--- a/skills/make-contracts/templates/Contracts/Doctrine/DoctrineMigrationInterface.php
+++ b/skills/make-contracts/templates/Contracts/Doctrine/DoctrineMigrationInterface.php
@@ -0,0 +1,18 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Contracts\Doctrine;
+
+use Doctrine\DBAL\Schema\Schema;
+
+interface DoctrineMigrationInterface
+{
+    public function up(Schema $schema): void;
+
+    public function down(Schema $schema): void;
+
+    public function description(): string;
+
+    public function isTransactional(): bool;
+}
--- a/skills/make-contracts/templates/Contracts/HasUrlsInterface.php
+++ b/skills/make-contracts/templates/Contracts/HasUrlsInterface.php
@@ -0,0 +1,10 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Contracts;
+
+interface HasUrlsInterface
+{
+    public function urls(): mixed;
+}
--- a/skills/make-contracts/templates/Contracts/InvalideDataInterface.php
+++ b/skills/make-contracts/templates/Contracts/InvalideDataInterface.php
@@ -0,0 +1,12 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Contracts;
+
+/**
+ * Marker interface for Invalide data objects.
+ */
+interface InvalideDataInterface
+{
+}
--- a/skills/make-contracts/templates/Contracts/InvalideInterface.php
+++ b/skills/make-contracts/templates/Contracts/InvalideInterface.php
@@ -0,0 +1,10 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Contracts;
+
+interface InvalideInterface
+{
+    public function invalide(): mixed;
+}
--- a/skills/make-contracts/templates/Contracts/OutDataInterface.php
+++ b/skills/make-contracts/templates/Contracts/OutDataInterface.php
@@ -0,0 +1,12 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Contracts;
+
+/**
+ * Marker interface for Out data objects.
+ */
+interface OutDataInterface
+{
+}
--- a/skills/make-contracts/templates/Contracts/OutInterface.php
+++ b/skills/make-contracts/templates/Contracts/OutInterface.php
@@ -0,0 +1,10 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Contracts;
+
+interface OutInterface
+{
+    public function out(): mixed;
+}
--- a/skills/make-contracts/templates/Contracts/Story/StoryInterface.php
+++ b/skills/make-contracts/templates/Contracts/Story/StoryInterface.php
@@ -0,0 +1,10 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Contracts\Story;
+
+interface StoryInterface
+{
+    public function build(): void;
+}
--- a/skills/make-contracts/templates/Contracts/UrlsDataInterface.php
+++ b/skills/make-contracts/templates/Contracts/UrlsDataInterface.php
@@ -0,0 +1,12 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Contracts;
+
+/**
+ * Marker interface for Urls data objects.
+ */
+interface UrlsDataInterface
+{
+}
--- a/skills/make-entity/README.md
+++ b/skills/make-entity/README.md
@@ -0,0 +1,107 @@
+# Framework Make Entity
+
+Génère une entité Doctrine avec repository selon principes Elegant Objects.
+
+## Vue d'ensemble
+Cette skill crée une entité Doctrine complète respectant les principes Elegant Objects, avec son repository et son interface.
+
+## Caractéristiques
+
+### Entité générée
+- Constructeur privé + factory statique `create()`
+- Classe `final`
+- Propriétés privées avec getters uniquement
+- Pas de setters (immutabilité encouragée)
+- Implémentation des interfaces de contrats
+- Traits Atournayre intégrés
+- Attributs Doctrine ORM configurés
+- Méthode `toLog()` pour LoggableInterface
+
+### Repository généré
+- Extends ServiceEntityRepository
+- Classe `final`
+- Interface dédiée
+- Prêt pour méthodes custom
+
+## Utilisation
+
+```bash
+Use skill framework:make:entity
+```
+
+Vous serez invité à fournir :
+1. Nom de l'entité (PascalCase)
+2. Liste des propriétés avec types
+
+## Exemple d'utilisation
+
+```bash
+EntityName: Product
+Properties:
+  - name: string
+  - description: string
+  - price: float
+  - stock: int
+  - isActive: bool
+```
+
+Génère :
+```php
+// src/Entity/Product.php
+final class Product implements LoggableInterface, DatabaseEntityInterface, ...
+{
+    use DatabaseTrait;
+    use NullTrait;
+    use DependencyInjectionTrait;
+
+    private function __construct(
+        #[ORM\Id]
+        #[ORM\Column(type: 'uuid')]
+        private Uuid $id,
+        #[ORM\Column(type: 'string')]
+        private string $name,
+        // ...
+    ) {}
+
+    public static function create(Uuid $id, string $name, ...): self
+    {
+        return new self(id: $id, name: $name, ...);
+    }
+
+    public function id(): Uuid { return $this->id; }
+    public function name(): string { return $this->name; }
+    // ...
+}
+```
+
+## Structure créée
+
+```
+src/
+├── Entity/
+│   └── {EntityName}.php
+└── Repository/
+    ├── {EntityName}Repository.php
+    └── {EntityName}RepositoryInterface.php
+```
+
+## Prérequis
+- Contracts doivent exister (appelle automatiquement `framework:make:contracts` si absents)
+- Projet Symfony avec Doctrine ORM configuré
+- Framework `atournayre/framework` installé
+
+## Types de propriétés supportés
+- Scalaires : `string`, `int`, `float`, `bool`
+- UUID : `Uuid` (Symfony\Component\Uid\Uuid)
+- DateTime : `\DateTimeImmutable`
+- Arrays : `array`
+- Relations Doctrine (à configurer manuellement après génération)
+
+## Principes Elegant Objects appliqués
+- Constructeur privé
+- Factory statique pour création
+- Classe finale (pas d'héritage)
+- Pas de setters publics
+- Propriétés privées avec getters
+- Interfaces pour tous les contrats
+- Immutabilité encouragée
--- a/skills/make-entity/SKILL.md
+++ b/skills/make-entity/SKILL.md
@@ -0,0 +1,108 @@
+---
+name: framework:make:entity
+description: Génère une entité Doctrine avec repository selon principes Elegant Objects
+license: MIT
+version: 1.0.0
+---
+
+# Framework Make Entity Skill
+
+## Description
+Génère une entité Doctrine complète avec son repository selon les principes Elegant Objects.
+
+L'entité générée inclut :
+- Constructeur privé avec factory statique `create()`
+- Traits Elegant Objects (DatabaseTrait, NullTrait, DependencyInjectionTrait)
+- Implémentation des interfaces de contrats
+- Repository avec interface
+
+## Usage
+```
+Use skill framework:make:entity
+
+Vous serez invité à fournir :
+- Le nom de l'entité (ex: Product, User, Order)
+- Les propriétés avec leurs types (ex: name:string, email:string, isActive:bool)
+```
+
+## Templates
+- `Entity/Utilisateur.php` - Template d'entité
+- `Repository/UtilisateurRepository.php` - Template de repository
+- `Repository/UtilisateurRepositoryInterface.php` - Template d'interface repository
+
+## Variables requises
+- **{EntityName}** - Nom de l'entité en PascalCase (ex: Utilisateur, Product)
+- **{entityName}** - Nom de l'entité en camelCase (ex: utilisateur, product)
+- **{namespace}** - Namespace du projet (défaut: App)
+- **{properties}** - Liste des propriétés avec types (array)
+
+## Dépendances
+- Requiert que les Contracts soient présents
+- Appelle automatiquement `framework:make:contracts` si les interfaces n'existent pas
+
+## Outputs
+- `src/Entity/{EntityName}.php`
+- `src/Repository/{EntityName}Repository.php`
+- `src/Repository/{EntityName}RepositoryInterface.php`
+
+## Workflow
+
+1. Demander le nom de l'entité (EntityName)
+2. Demander les propriétés (nom, type, nullable)
+3. Vérifier si `src/Contracts/` existe
+   - Si non : appeler `framework:make:contracts`
+4. Générer l'entité depuis le template :
+   - Remplacer `{EntityName}` par le nom fourni
+   - Remplacer `{entityName}` par la version camelCase
+   - Générer les propriétés dans le constructeur
+   - Générer les méthodes getter pour chaque propriété
+5. Générer le repository et son interface
+6. Afficher le résumé des fichiers créés
+
+## Patterns appliqués
+
+### Entité
+- Classe `final`
+- Constructeur privé
+- Factory statique `create()` pour instanciation
+- Traits : DatabaseTrait, NullTrait, DependencyInjectionTrait
+- Attributs Doctrine ORM (#[ORM\Entity], #[ORM\Id], #[ORM\Column])
+- Implémentation des interfaces :
+  - LoggableInterface
+  - DatabaseEntityInterface
+  - NullableInterface
+  - DependencyInjectionAwareInterface
+  - OutInterface
+  - HasUrlsInterface
+  - InvalideInterface
+
+### Repository
+- Classe `final`
+- Extends ServiceEntityRepository
+- Implémente l'interface du repository
+- Constructeur avec ManagerRegistry uniquement
+
+## Exemple
+
+```bash
+Use skill framework:make:entity
+
+# Saisies utilisateur :
+EntityName: Product
+Properties:
+  - id: Uuid
+  - name: string
+  - price: float
+  - isActive: bool
+
+# Résultat :
+✓ src/Entity/Product.php
+✓ src/Repository/ProductRepository.php
+✓ src/Repository/ProductRepositoryInterface.php
+```
+
+## Notes
+- L'ID de type Uuid est ajouté automatiquement
+- Les propriétés sont toujours privées avec getters
+- Pas de setters (immutabilité)
+- La méthode `toLog()` inclut automatiquement toutes les propriétés
--- a/skills/make-entity/templates/Entity/Utilisateur.php
+++ b/skills/make-entity/templates/Entity/Utilisateur.php
@@ -0,0 +1,85 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Entity;
+
+use App\Contracts\HasUrlsInterface;
+use App\Contracts\InvalideInterface;
+use App\Contracts\OutInterface;
+use App\Invalide\UtilisateurInvalide;
+use App\MessageHandler\UtilisateurUrlsMessage;
+use App\Out\UtilisateurOut;
+use App\Repository\UtilisateurRepository;
+use App\Urls\UtilisateurUrls;
+use Atournayre\Common\Persistance\DatabaseTrait;
+use Atournayre\Contracts\DependencyInjection\DependencyInjectionAwareInterface;
+use Atournayre\Contracts\Log\LoggableInterface;
+use Atournayre\Contracts\Null\NullableInterface;
+use Atournayre\Contracts\Persistance\DatabaseEntityInterface;
+use Atournayre\Null\NullTrait;
+use Atournayre\Traits\DependencyInjectionTrait;
+use Doctrine\ORM\Mapping as ORM;
+use Symfony\Component\Uid\Uuid;
+
+#[ORM\Entity(repositoryClass: UtilisateurRepository::class)]
+final class Utilisateur implements LoggableInterface, DatabaseEntityInterface, NullableInterface, DependencyInjectionAwareInterface, OutInterface, HasUrlsInterface, InvalideInterface
+{
+    use DatabaseTrait;
+    use DependencyInjectionTrait;
+    use NullTrait;
+
+    private function __construct(
+        #[ORM\Id]
+        #[ORM\Column(type: 'uuid')]
+        private Uuid $id,
+    ) {
+    }
+
+    public static function create(
+        Uuid $id,
+    ): self {
+        return new self(
+            id: $id,
+        );
+    }
+
+    public function id(): Uuid
+    {
+        return $this->id;
+    }
+
+    /**
+     * @return array<string, mixed>
+     */
+    public function toLog(): array
+    {
+        return [
+            'id' => $this->id,
+        ];
+    }
+
+    public function invalide(): UtilisateurInvalide
+    {
+        return UtilisateurInvalide::new(
+            utilisateur: $this,
+        );
+    }
+
+    public function out(): UtilisateurOut
+    {
+        return UtilisateurOut::new(
+            utilisateur: $this,
+        );
+    }
+
+    public function urls(): UtilisateurUrls
+    {
+        /** @var UtilisateurUrls $urls */
+        $urls = UtilisateurUrlsMessage::new(
+            id: $this->id->toRfc4122(),
+        )->query($this->dependencyInjection()->queryBus());
+
+        return $urls;
+    }
+}
--- a/skills/make-entity/templates/Repository/UtilisateurRepository.php
+++ b/skills/make-entity/templates/Repository/UtilisateurRepository.php
@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Repository;
+
+use App\Entity\Utilisateur;
+use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
+use Doctrine\Persistence\ManagerRegistry;
+
+/**
+ * @extends ServiceEntityRepository<Utilisateur>
+ */
+final class UtilisateurRepository extends ServiceEntityRepository implements UtilisateurRepositoryInterface
+{
+    public function __construct(ManagerRegistry $registry)
+    {
+        parent::__construct($registry, Utilisateur::class);
+    }
+}
--- a/skills/make-entity/templates/Repository/UtilisateurRepositoryInterface.php
+++ b/skills/make-entity/templates/Repository/UtilisateurRepositoryInterface.php
@@ -0,0 +1,9 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Repository;
+
+interface UtilisateurRepositoryInterface
+{
+}
--- a/skills/make-factory/README.md
+++ b/skills/make-factory/README.md
@@ -0,0 +1,275 @@
+# Framework Make Factory
+
+Génère une Factory Foundry pour tests.
+
+## Vue d'ensemble
+Cette skill crée une Factory Zenstruck Foundry pour générer facilement des instances d'entités dans les tests selon les principes Elegant Objects.
+
+## Caractéristiques
+
+### Classe Factory générée
+- Extends PersistentObjectFactory
+- Classe `final`
+- Méthode `class()` retournant le FQCN
+- Méthode `defaults()` avec valeurs Faker
+- Méthode `initialize()` utilisant `instantiateWith()`
+- Appelle la factory statique `Entity::create()`
+- Méthode `withSpecificId()` par défaut
+
+## Utilisation
+
+```bash
+Use skill framework:make:factory
+```
+
+Vous serez invité à fournir le nom de l'entité.
+
+## Exemple d'utilisation
+
+```bash
+EntityName: Product
+```
+
+Génère :
+```php
+// src/Factory/ProductFactory.php
+/**
+ * @extends PersistentObjectFactory<Product>
+ */
+final class ProductFactory extends PersistentObjectFactory
+{
+    public static function class(): string
+    {
+        return Product::class;
+    }
+
+    protected function defaults(): array|callable
+    {
+        return [
+            'id' => Uuid::v4(),
+            'name' => self::faker()->words(3, true),
+            'price' => self::faker()->randomFloat(2, 10, 1000),
+        ];
+    }
+
+    protected function initialize(): static
+    {
+        return $this
+            ->instantiateWith(function (array $attributes) {
+                return Product::create(
+                    id: $attributes['id'],
+                    name: $attributes['name'],
+                    price: $attributes['price'],
+                );
+            });
+    }
+
+    public function withSpecificId(string $uuid): self
+    {
+        return $this->with([
+            'id' => Uuid::fromString($uuid),
+        ]);
+    }
+}
+```
+
+## Structure créée
+
+```
+src/
+└── Factory/
+    └── {EntityName}Factory.php
+```
+
+## Prérequis
+- L'entité doit exister dans `src/Entity/{EntityName}.php`
+- Zenstruck Foundry installé
+
+## Usage dans les tests
+
+### Création basique
+```php
+use App\Factory\ProductFactory;
+
+// Créer et persister une instance
+$product = ProductFactory::createOne();
+
+// Créer plusieurs instances
+$products = ProductFactory::createMany(10);
+
+// Créer sans persister
+$product = ProductFactory::new()->withoutPersisting()->create();
+```
+
+### Personnalisation
+```php
+// Override propriétés
+$product = ProductFactory::createOne([
+    'name' => 'Mon Produit',
+    'price' => 99.99,
+]);
+
+// Enchaînement
+$product = ProductFactory::new()
+    ->withSpecificId('018d5e5e-5e5e-7e5e-ae5e-5e5e5e5e5e5e')
+    ->with(['name' => 'Custom'])
+    ->createOne();
+```
+
+### Tests unitaires
+```php
+final class ProductTest extends TestCase
+{
+    public function testProductCanBeCreated(): void
+    {
+        $product = ProductFactory::createOne([
+            'name' => 'Test Product',
+            'price' => 50.0,
+        ]);
+
+        self::assertSame('Test Product', $product->name());
+        self::assertSame(50.0, $product->price());
+    }
+
+    public function testCannotHaveNegativePrice(): void
+    {
+        $this->expectException(\InvalidArgumentException::class);
+
+        ProductFactory::createOne(['price' => -10.0]);
+    }
+}
+```
+
+### Tests fonctionnels
+```php
+final class ProductControllerTest extends WebTestCase
+{
+    public function testListProducts(): void
+    {
+        ProductFactory::createMany(5);
+
+        $client = static::createClient();
+        $client->request('GET', '/products');
+
+        self::assertResponseIsSuccessful();
+        self::assertSelectorTextContains('h1', 'Products');
+    }
+}
+```
+
+## Enrichissement (principe YAGNI)
+
+Ajouter méthodes custom **uniquement si demandées** :
+
+```php
+// États métier
+public function active(): self
+{
+    return $this->with(['isActive' => true]);
+}
+
+public function inactive(): self
+{
+    return $this->with(['isActive' => false]);
+}
+
+// Valeurs spécifiques
+public function expensive(): self
+{
+    return $this->with([
+        'price' => self::faker()->randomFloat(2, 500, 2000)
+    ]);
+}
+
+public function outOfStock(): self
+{
+    return $this->with(['stock' => 0]);
+}
+
+// Relations
+public function withCategory(Category $category): self
+{
+    return $this->with(['category' => $category]);
+}
+```
+
+## Valeurs par défaut Faker
+
+```php
+protected function defaults(): array|callable
+{
+    return [
+        // UUID
+        'id' => Uuid::v4(),
+
+        // Strings
+        'name' => self::faker()->words(3, true),
+        'email' => self::faker()->email(),
+        'description' => self::faker()->paragraph(),
+        'slug' => self::faker()->slug(),
+
+        // Nombres
+        'price' => self::faker()->randomFloat(2, 10, 1000),
+        'quantity' => self::faker()->numberBetween(1, 100),
+        'stock' => self::faker()->numberBetween(0, 50),
+
+        // Booleans
+        'isActive' => true,
+        'isPublished' => self::faker()->boolean(70), // 70% true
+
+        // Dates
+        'createdAt' => \DateTimeImmutable::createFromMutable(
+            self::faker()->dateTimeBetween('-1 year')
+        ),
+
+        // Arrays
+        'tags' => self::faker()->words(5),
+
+        // Relations (avec autre Factory)
+        'category' => CategoryFactory::new(),
+    ];
+}
+```
+
+## Patterns avancés
+
+### Factory avec relations
+```php
+protected function defaults(): array|callable
+{
+    return [
+        'id' => Uuid::v4(),
+        'name' => self::faker()->words(3, true),
+        'category' => CategoryFactory::new(),
+    ];
+}
+
+public function inCategory(Category $category): self
+{
+    return $this->with(['category' => $category]);
+}
+```
+
+### Factory avec états complexes
+```php
+public function published(): self
+{
+    return $this
+        ->with(['isPublished' => true])
+        ->with(['publishedAt' => new \DateTimeImmutable()]);
+}
+
+public function draft(): self
+{
+    return $this
+        ->with(['isPublished' => false])
+        ->with(['publishedAt' => null]);
+}
+```
+
+## Principes Elegant Objects appliqués
+- Classe finale
+- Utilise `instantiateWith()` pour appeler `Entity::create()`
+- Pas de `new Entity()` direct
+- Méthodes custom uniquement si demandées (YAGNI)
+- Type-safe avec générique PHPDoc
--- a/skills/make-factory/SKILL.md
+++ b/skills/make-factory/SKILL.md
@@ -0,0 +1,256 @@
+---
+name: framework:make:factory
+description: Génère Factory Foundry pour tests
+license: MIT
+version: 1.0.0
+---
+
+# Framework Make Factory Skill
+
+## Description
+Génère une Factory Foundry pour créer facilement des instances d'entités dans les tests.
+
+La Factory utilise Zenstruck Foundry et respecte les principes Elegant Objects en utilisant la factory statique `create()` de l'entité.
+
+## Usage
+```
+Use skill framework:make:factory
+
+Vous serez invité à fournir :
+- Le nom de l'entité (ex: Product, User, Order)
+```
+
+## Templates
+- `Factory/UtilisateurFactory.php` - Template de factory Foundry
+
+## Variables requises
+- **{EntityName}** - Nom de l'entité en PascalCase (ex: Utilisateur, Product)
+- **{entityName}** - Nom de l'entité en camelCase (ex: utilisateur, product)
+- **{namespace}** - Namespace du projet (défaut: App)
+- **{properties}** - Liste des propriétés de l'entité pour `defaults()`
+
+## Dépendances
+- Requiert que l'entité existe dans `src/Entity/{EntityName}.php`
+- Requiert Zenstruck Foundry installé
+
+## Outputs
+- `src/Factory/{EntityName}Factory.php`
+
+## Workflow
+
+1. Demander le nom de l'entité (EntityName)
+2. Vérifier que l'entité existe dans `src/Entity/{EntityName}.php`
+   - Si non : arrêter et demander de créer l'entité d'abord
+3. Lire l'entité pour détecter les propriétés du constructeur `create()`
+4. Générer la factory depuis le template :
+   - Remplacer `{EntityName}` par le nom fourni
+   - Remplacer `{entityName}` par la version camelCase
+   - Générer `defaults()` avec valeurs par défaut pour chaque propriété
+   - Générer `instantiateWith()` appelant `Entity::create()`
+5. Afficher le fichier créé
+
+## Patterns appliqués
+
+### Classe Factory
+- Extends PersistentObjectFactory
+- Classe `final`
+- Méthode statique `class()` retournant le FQCN de l'entité
+- Méthode `defaults()` avec valeurs par défaut des propriétés
+- Méthode `initialize()` avec `instantiateWith()` appelant `Entity::create()`
+- Méthodes custom (ex: `withSpecificId()`)
+
+## Exemple
+
+```bash
+Use skill framework:make:factory
+
+# Saisies utilisateur :
+EntityName: Product
+
+# Résultat :
+✓ src/Factory/ProductFactory.php
+```
+
+Fichier généré :
+```php
+<?php
+
+declare(strict_types=1);
+
+namespace App\Factory;
+
+use App\Entity\Product;
+use Symfony\Component\Uid\Uuid;
+use Zenstruck\Foundry\Persistence\PersistentObjectFactory;
+
+/**
+ * @extends PersistentObjectFactory<Product>
+ */
+final class ProductFactory extends PersistentObjectFactory
+{
+    public static function class(): string
+    {
+        return Product::class;
+    }
+
+    protected function defaults(): array|callable
+    {
+        return [
+            'id' => Uuid::v4(),
+            'name' => self::faker()->words(3, true),
+            'price' => self::faker()->randomFloat(2, 10, 1000),
+            'stock' => self::faker()->numberBetween(0, 100),
+            'isActive' => true,
+        ];
+    }
+
+    protected function initialize(): static
+    {
+        return $this
+            ->instantiateWith(function (array $attributes) {
+                return Product::create(
+                    id: $attributes['id'],
+                    name: $attributes['name'],
+                    price: $attributes['price'],
+                    stock: $attributes['stock'],
+                    isActive: $attributes['isActive'],
+                );
+            })
+        ;
+    }
+
+    public function withSpecificId(string $uuid): self
+    {
+        return $this->with([
+            'id' => Uuid::fromString($uuid),
+        ]);
+    }
+
+    public function inactive(): self
+    {
+        return $this->with(['isActive' => false]);
+    }
+
+    public function outOfStock(): self
+    {
+        return $this->with(['stock' => 0]);
+    }
+}
+```
+
+## Usage dans les tests
+
+### Création simple
+```php
+// Crée et persiste en DB
+$product = ProductFactory::createOne();
+
+// Crée plusieurs instances
+$products = ProductFactory::createMany(10);
+
+// Crée sans persister
+$product = ProductFactory::new()->withoutPersisting()->create();
+```
+
+### Personnalisation
+```php
+// Override propriétés
+$product = ProductFactory::createOne([
+    'name' => 'Custom Product',
+    'price' => 99.99,
+]);
+
+// Méthodes custom
+$product = ProductFactory::new()
+    ->withSpecificId('018d5e5e-5e5e-7e5e-ae5e-5e5e5e5e5e5e')
+    ->inactive()
+    ->createOne();
+
+$product = ProductFactory::new()->outOfStock()->createOne();
+```
+
+### Dans les tests
+```php
+final class ProductTest extends TestCase
+{
+    public function testCannotDecreaseStockWhenOutOfStock(): void
+    {
+        $product = ProductFactory::new()->outOfStock()->createOne();
+
+        $this->expectException(\DomainException::class);
+        $product->decreaseStock(1);
+    }
+
+    public function testInactiveProductsCannotBePurchased(): void
+    {
+        $product = ProductFactory::new()->inactive()->createOne();
+
+        $this->expectException(\DomainException::class);
+        $product->purchase(1);
+    }
+}
+```
+
+## Valeurs par défaut recommandées
+
+### Types courants
+```php
+// Strings
+'name' => self::faker()->words(3, true),
+'email' => self::faker()->email(),
+'description' => self::faker()->paragraph(),
+
+// Nombres
+'price' => self::faker()->randomFloat(2, 10, 1000),
+'quantity' => self::faker()->numberBetween(1, 100),
+'stock' => self::faker()->numberBetween(0, 50),
+
+// Booleans
+'isActive' => true,
+'isPublished' => self::faker()->boolean(),
+
+// Dates
+'createdAt' => \DateTimeImmutable::createFromMutable(self::faker()->dateTime()),
+
+// UUID
+'id' => Uuid::v4(),
+```
+
+## Méthodes custom recommandées
+
+```php
+// Par ID spécifique
+public function withSpecificId(string $uuid): self
+{
+    return $this->with(['id' => Uuid::fromString($uuid)]);
+}
+
+// États métier
+public function active(): self
+{
+    return $this->with(['isActive' => true]);
+}
+
+public function inactive(): self
+{
+    return $this->with(['isActive' => false]);
+}
+
+// Valeurs spécifiques
+public function expensive(): self
+{
+    return $this->with(['price' => self::faker()->randomFloat(2, 500, 2000)]);
+}
+
+public function cheap(): self
+{
+    return $this->with(['price' => self::faker()->randomFloat(2, 1, 50)]);
+}
+```
+
+## Notes
+- Utilise `instantiateWith()` pour appeler la factory statique `create()` de l'entité
+- Respecte le principe Elegant Objects (pas de `new Entity()` direct)
+- Faker disponible via `self::faker()`
+- Méthodes custom uniquement si demandées explicitement (YAGNI)
+- Factory persiste par défaut, utiliser `withoutPersisting()` si besoin
--- a/skills/make-factory/templates/Factory/UtilisateurFactory.php
+++ b/skills/make-factory/templates/Factory/UtilisateurFactory.php
@@ -0,0 +1,45 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Factory;
+
+use App\Entity\Utilisateur;
+use Symfony\Component\Uid\Uuid;
+use Zenstruck\Foundry\Persistence\PersistentObjectFactory;
+
+/**
+ * @extends PersistentObjectFactory<Utilisateur>
+ */
+final class UtilisateurFactory extends PersistentObjectFactory
+{
+    public static function class(): string
+    {
+        return Utilisateur::class;
+    }
+
+    protected function defaults(): array|callable
+    {
+        return [
+            'id' => Uuid::v4(),
+        ];
+    }
+
+    protected function initialize(): static
+    {
+        return $this
+            ->instantiateWith(function (array $attributes) {
+                return Utilisateur::create(
+                    id: $attributes['id'],
+                );
+            })
+        ;
+    }
+
+    public function withSpecificId(string $uuid): self
+    {
+        return $this->with([
+            'id' => Uuid::fromString($uuid),
+        ]);
+    }
+}
--- a/skills/make-invalide/README.md
+++ b/skills/make-invalide/README.md
@@ -0,0 +1,191 @@
+# Framework Make Invalide
+
+Génère une classe Invalide pour exceptions métier d'une entité.
+
+## Vue d'ensemble
+Cette skill crée une classe Invalide qui encapsule les exceptions métier spécifiques à une entité selon les principes Elegant Objects.
+
+## Caractéristiques
+
+### Classe Invalide générée
+- Classe `final`
+- Constructeur privé
+- Factory statique `new()`
+- Encapsule l'entité
+- Base pour méthodes factory d'exceptions
+
+## Utilisation
+
+```bash
+Use skill framework:make:invalide
+```
+
+Vous serez invité à fournir le nom de l'entité.
+
+## Exemple d'utilisation
+
+```bash
+EntityName: Product
+```
+
+Génère :
+```php
+// src/Invalide/ProductInvalide.php
+final class ProductInvalide
+{
+    private function __construct(
+        private Product $product,
+    ) {}
+
+    public static function new(Product $product): self
+    {
+        return new self(product: $product);
+    }
+}
+```
+
+## Structure créée
+
+```
+src/
+└── Invalide/
+    └── {EntityName}Invalide.php
+```
+
+## Prérequis
+- L'entité doit exister dans `src/Entity/{EntityName}.php`
+
+## Usage recommandé
+
+### Dans l'entité
+```php
+final class Product implements InvalideInterface
+{
+    public function invalide(): ProductInvalide
+    {
+        return ProductInvalide::new(product: $this);
+    }
+}
+```
+
+### Enrichissement avec exceptions métier
+
+```php
+final class ProductInvalide
+{
+    private function __construct(
+        private Product $product,
+    ) {}
+
+    public static function new(Product $product): self
+    {
+        return new self(product: $product);
+    }
+
+    // Exceptions de validation
+    public static function carNomVide(): \InvalidArgumentException
+    {
+        return new \InvalidArgumentException(
+            'Le nom du produit ne peut pas être vide'
+        );
+    }
+
+    public static function carPrixNegatif(): \InvalidArgumentException
+    {
+        return new \InvalidArgumentException(
+            'Le prix ne peut pas être négatif'
+        );
+    }
+
+    // Exceptions métier
+    public static function carStockInsuffisant(
+        int $demande,
+        int $disponible
+    ): \DomainException {
+        return new \DomainException(
+            sprintf(
+                'Stock insuffisant: %d demandé, %d disponible',
+                $demande,
+                $disponible
+            )
+        );
+    }
+
+    public static function carProduitInactif(string $id): \DomainException
+    {
+        return new \DomainException(
+            sprintf('Le produit %s est inactif', $id)
+        );
+    }
+}
+```
+
+### Utilisation dans le code
+
+```php
+// Validation dans factory
+public static function create(
+    Uuid $id,
+    string $name,
+    float $price
+): self {
+    if ('' === $name) {
+        throw ProductInvalide::carNomVide();
+    }
+    if ($price < 0) {
+        throw ProductInvalide::carPrixNegatif();
+    }
+    return new self(id: $id, name: $name, price: $price);
+}
+
+// Validation métier
+public function decreaseStock(int $quantity): void
+{
+    if (!$this->isActive) {
+        throw ProductInvalide::carProduitInactif($this->id->toRfc4122());
+    }
+    if ($this->stock < $quantity) {
+        throw ProductInvalide::carStockInsuffisant(
+            demande: $quantity,
+            disponible: $this->stock
+        );
+    }
+    $this->stock -= $quantity;
+}
+```
+
+## Conventions de nommage
+
+### Méthodes factory
+- Préfixe : `car` (français)
+- Format : `carRaisonDeLErreur`
+- Exemples :
+  - `carNomVide()`
+  - `carEmailInvalide()`
+  - `carStockInsuffisant()`
+  - `carProduitInactif()`
+
+### Messages d'exception
+- Pas de point final
+- Inclure le contexte maximum
+- Une seule phrase sans points internes
+- Exemples :
+  - ✅ `'Le nom du produit ne peut pas être vide'`
+  - ✅ `'Stock insuffisant: 5 demandé, 2 disponible'`
+  - ❌ `'Erreur.'`
+  - ❌ `'Le nom est vide. Veuillez le renseigner.'`
+
+## Types d'exceptions recommandés
+
+- `\InvalidArgumentException` - Validation d'arguments
+- `\DomainException` - Règles métier
+- `\LogicException` - État incohérent
+- `\RuntimeException` - Erreur runtime
+
+## Principes Elegant Objects appliqués
+- Classe finale
+- Constructeur privé
+- Factory statiques
+- Fail fast
+- Messages d'erreur avec contexte
+- Exceptions spécifiques au domaine
--- a/skills/make-invalide/SKILL.md
+++ b/skills/make-invalide/SKILL.md
@@ -0,0 +1,185 @@
+---
+name: framework:make:invalide
+description: Génère classe Invalide (exceptions métier)
+license: MIT
+version: 1.0.0
+---
+
+# Framework Make Invalide Skill
+
+## Description
+Génère une classe Invalide pour gérer les exceptions métier d'une entité.
+
+La classe Invalide encapsule l'entité et fournit des factory methods pour créer des exceptions spécifiques au contexte métier.
+
+## Usage
+```
+Use skill framework:make:invalide
+
+Vous serez invité à fournir :
+- Le nom de l'entité (ex: Product, User, Order)
+```
+
+## Templates
+- `Invalide/UtilisateurInvalide.php` - Template de classe Invalide
+
+## Variables requises
+- **{EntityName}** - Nom de l'entité en PascalCase (ex: Utilisateur, Product)
+- **{entityName}** - Nom de l'entité en camelCase (ex: utilisateur, product)
+- **{namespace}** - Namespace du projet (défaut: App)
+
+## Dépendances
+- Requiert que l'entité existe dans `src/Entity/{EntityName}.php`
+
+## Outputs
+- `src/Invalide/{EntityName}Invalide.php`
+
+## Workflow
+
+1. Demander le nom de l'entité (EntityName)
+2. Vérifier que l'entité existe dans `src/Entity/{EntityName}.php`
+   - Si non : arrêter et demander de créer l'entité d'abord
+3. Générer la classe Invalide depuis le template :
+   - Remplacer `{EntityName}` par le nom fourni
+   - Remplacer `{entityName}` par la version camelCase
+4. Afficher le fichier créé
+
+## Patterns appliqués
+
+### Classe Invalide
+- Classe `final`
+- Constructeur privé
+- Factory statique `new()` pour instanciation
+- Propriété privée de type entité
+- Méthodes factory statiques pour exceptions spécifiques
+
+## Exemple
+
+```bash
+Use skill framework:make:invalide
+
+# Saisies utilisateur :
+EntityName: Product
+
+# Résultat :
+✓ src/Invalide/ProductInvalide.php
+```
+
+Fichier généré :
+```php
+<?php
+
+declare(strict_types=1);
+
+namespace App\Invalide;
+
+use App\Entity\Product;
+
+final class ProductInvalide
+{
+    private function __construct(
+        private Product $product,
+    ) {
+    }
+
+    public static function new(
+        Product $product,
+    ): self {
+        return new self(
+            product: $product,
+        );
+    }
+}
+```
+
+## Usage dans l'entité
+
+L'entité doit implémenter la méthode `invalide()` :
+
+```php
+public function invalide(): ProductInvalide
+{
+    return ProductInvalide::new(
+        product: $this,
+    );
+}
+```
+
+## Enrichissement avec exceptions métier
+
+Ajouter des méthodes factory pour les cas d'erreur spécifiques :
+
+```php
+final class ProductInvalide
+{
+    private function __construct(
+        private Product $product,
+    ) {}
+
+    public static function new(Product $product): self
+    {
+        return new self(product: $product);
+    }
+
+    public static function carPrixNegatif(): \InvalidArgumentException
+    {
+        return new \InvalidArgumentException(
+            'Le prix du produit ne peut pas être négatif'
+        );
+    }
+
+    public static function carStockInsuffisant(int $demande, int $disponible): \DomainException
+    {
+        return new \DomainException(
+            sprintf(
+                'Stock insuffisant: %d demandé, %d disponible',
+                $demande,
+                $disponible
+            )
+        );
+    }
+
+    public static function carNomVide(): \InvalidArgumentException
+    {
+        return new \InvalidArgumentException(
+            'Le nom du produit ne peut pas être vide'
+        );
+    }
+}
+```
+
+## Usage des exceptions
+
+```php
+final class Product
+{
+    public static function create(Uuid $id, string $name, float $price): self
+    {
+        if ('' === $name) {
+            throw ProductInvalide::carNomVide();
+        }
+        if ($price < 0) {
+            throw ProductInvalide::carPrixNegatif();
+        }
+        return new self(id: $id, name: $name, price: $price);
+    }
+
+    public function decreaseStock(int $quantity): void
+    {
+        if ($this->stock < $quantity) {
+            throw ProductInvalide::carStockInsuffisant(
+                demande: $quantity,
+                disponible: $this->stock
+            );
+        }
+        // ...
+    }
+}
+```
+
+## Notes
+- Les méthodes factory d'exceptions doivent commencer par `car` (convention)
+- Les messages d'exception ne doivent pas finir par un point
+- Les messages doivent inclure le maximum de contexte
+- Privilégier les exceptions standard PHP (\InvalidArgumentException, \DomainException)
+- Respecte le principe "fail fast"
--- a/skills/make-invalide/templates/Invalide/UtilisateurInvalide.php
+++ b/skills/make-invalide/templates/Invalide/UtilisateurInvalide.php
@@ -0,0 +1,23 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Invalide;
+
+use App\Entity\Utilisateur;
+
+final class UtilisateurInvalide
+{
+    private function __construct(
+        private Utilisateur $utilisateur,
+    ) {
+    }
+
+    public static function new(
+        Utilisateur $utilisateur,
+    ): self {
+        return new self(
+            utilisateur: $utilisateur,
+        );
+    }
+}
--- a/skills/make-out/README.md
+++ b/skills/make-out/README.md
@@ -0,0 +1,118 @@
+# Framework Make Out
+
+Génère une classe Out (DTO immuable pour output).
+
+## Vue d'ensemble
+Cette skill crée une classe Out qui sert de Data Transfer Object immuable pour exposer les données d'une entité vers l'extérieur.
+
+## Caractéristiques
+
+### Classe Out générée
+- Classe `final readonly` (PHP 8.2+)
+- Constructeur privé
+- Factory statique `new()`
+- Encapsule l'entité
+- Complètement immuable
+- Couche anti-corruption
+
+## Utilisation
+
+```bash
+Use skill framework:make:out
+```
+
+Vous serez invité à fournir le nom de l'entité.
+
+## Exemple d'utilisation
+
+```bash
+EntityName: Product
+```
+
+Génère :
+```php
+// src/Out/ProductOut.php
+final readonly class ProductOut
+{
+    private function __construct(
+        private Product $product,
+    ) {}
+
+    public static function new(Product $product): self
+    {
+        return new self(product: $product);
+    }
+}
+```
+
+## Structure créée
+
+```
+src/
+└── Out/
+    └── {EntityName}Out.php
+```
+
+## Prérequis
+- L'entité doit exister dans `src/Entity/{EntityName}.php`
+- PHP 8.2+ pour readonly classes
+
+## Usage recommandé
+
+### Dans l'entité
+```php
+final class Product implements OutInterface
+{
+    public function out(): ProductOut
+    {
+        return ProductOut::new(product: $this);
+    }
+}
+```
+
+### Dans un contrôleur
+```php
+#[Route('/api/products/{id}', methods: ['GET'])]
+public function show(Product $product): JsonResponse
+{
+    return $this->json($product->out());
+}
+```
+
+### Ajout de méthodes exposées
+```php
+final readonly class ProductOut
+{
+    private function __construct(
+        private Product $product,
+    ) {}
+
+    public static function new(Product $product): self
+    {
+        return new self(product: $product);
+    }
+
+    public function id(): string
+    {
+        return $this->product->id()->toRfc4122();
+    }
+
+    public function name(): string
+    {
+        return $this->product->name();
+    }
+
+    public function formattedPrice(): string
+    {
+        return number_format($this->product->price(), 2) . ' €';
+    }
+}
+```
+
+## Principes Elegant Objects appliqués
+- Classe finale
+- Constructeur privé
+- Factory statique
+- Immutabilité totale (readonly)
+- Encapsulation de l'entité
+- Pas de getters bruts, méthodes métier
--- a/skills/make-out/SKILL.md
+++ b/skills/make-out/SKILL.md
@@ -0,0 +1,112 @@
+---
+name: framework:make:out
+description: Génère classe Out (DTO immuable pour output)
+license: MIT
+version: 1.0.0
+---
+
+# Framework Make Out Skill
+
+## Description
+Génère une classe Out (Data Transfer Object) immuable pour représenter les données de sortie d'une entité.
+
+La classe Out est un DTO readonly qui encapsule une entité pour l'exposition vers l'extérieur (API, vues, etc.).
+
+## Usage
+```
+Use skill framework:make:out
+
+Vous serez invité à fournir :
+- Le nom de l'entité (ex: Product, User, Order)
+```
+
+## Templates
+- `Out/UtilisateurOut.php` - Template de classe Out
+
+## Variables requises
+- **{EntityName}** - Nom de l'entité en PascalCase (ex: Utilisateur, Product)
+- **{entityName}** - Nom de l'entité en camelCase (ex: utilisateur, product)
+- **{namespace}** - Namespace du projet (défaut: App)
+
+## Dépendances
+- Requiert que l'entité existe dans `src/Entity/{EntityName}.php`
+
+## Outputs
+- `src/Out/{EntityName}Out.php`
+
+## Workflow
+
+1. Demander le nom de l'entité (EntityName)
+2. Vérifier que l'entité existe dans `src/Entity/{EntityName}.php`
+   - Si non : arrêter et demander de créer l'entité d'abord
+3. Générer la classe Out depuis le template :
+   - Remplacer `{EntityName}` par le nom fourni
+   - Remplacer `{entityName}` par la version camelCase
+4. Afficher le fichier créé
+
+## Patterns appliqués
+
+### Classe Out
+- Classe `final readonly`
+- Constructeur privé
+- Factory statique `new()` pour instanciation
+- Propriété privée de type entité
+- Objet complètement immuable
+
+## Exemple
+
+```bash
+Use skill framework:make:out
+
+# Saisies utilisateur :
+EntityName: Product
+
+# Résultat :
+✓ src/Out/ProductOut.php
+```
+
+Fichier généré :
+```php
+<?php
+
+declare(strict_types=1);
+
+namespace App\Out;
+
+use App\Entity\Product;
+
+final readonly class ProductOut
+{
+    private function __construct(
+        private Product $product,
+    ) {
+    }
+
+    public static function new(
+        Product $product,
+    ): self {
+        return new self(
+            product: $product,
+        );
+    }
+}
+```
+
+## Usage dans l'entité
+
+L'entité doit implémenter la méthode `out()` :
+
+```php
+public function out(): ProductOut
+{
+    return ProductOut::new(
+        product: $this,
+    );
+}
+```
+
+## Notes
+- La classe Out peut être enrichie avec des méthodes pour exposer des propriétés calculées
+- Elle sert de couche anti-corruption entre le domaine et l'extérieur
+- Permet de contrôler finement ce qui est exposé depuis l'entité
+- Respecte le principe d'immutabilité (readonly)
--- a/skills/make-story/README.md
+++ b/skills/make-story/README.md
@@ -0,0 +1,311 @@
+# Framework Make Story
+
+Génère une Story Foundry pour fixtures de tests.
+
+## Vue d'ensemble
+Cette skill crée une Story Zenstruck Foundry pour orchestrer la création de fixtures de tests cohérentes et réutilisables.
+
+## Caractéristiques
+
+### Classe Story générée
+- Extends Story
+- Implements StoryInterface
+- Classe `final`
+- Méthode `build()` avec scénarios
+- Utilise Factories pour créer instances
+- Scénarios prédéfinis
+
+### Classe AppStory
+- Point d'entrée global
+- Attribut #[AsFixture(name: 'main')]
+- Charge toutes les stories
+- Gère les dépendances entre stories
+
+## Utilisation
+
+```bash
+Use skill framework:make:story
+```
+
+Vous serez invité à fournir le nom de l'entité.
+
+## Exemple d'utilisation
+
+```bash
+EntityName: Product
+```
+
+Génère :
+```php
+// src/Story/ProductStory.php
+final class ProductStory extends Story implements StoryInterface
+{
+    public function build(): void
+    {
+        // Produit par défaut
+        ProductFactory::createOne();
+
+        // Produits avec IDs spécifiques
+        ProductFactory::new()
+            ->withSpecificId('01234567-89ab-cdef-0123-456789abcdef')
+            ->create();
+
+        // Plusieurs produits
+        ProductFactory::createMany(10);
+    }
+}
+
+// src/Story/AppStory.php (updated)
+#[AsFixture(name: 'main')]
+final class AppStory extends Story implements StoryInterface
+{
+    public function build(): void
+    {
+        ProductStory::load();
+        // ... autres stories
+    }
+}
+```
+
+## Structure créée
+
+```
+src/
+└── Story/
+    ├── {EntityName}Story.php
+    └── AppStory.php
+```
+
+## Prérequis
+- L'entité doit exister
+- La Factory doit exister (créée automatiquement si absente)
+- StoryInterface doit exister dans Contracts
+- Zenstruck Foundry installé
+
+## Usage dans les tests
+
+### Tests unitaires
+```php
+use App\Story\ProductStory;
+
+final class ProductServiceTest extends TestCase
+{
+    protected function setUp(): void
+    {
+        ProductStory::load();
+    }
+
+    public function testCalculateTotalPrice(): void
+    {
+        $products = ProductFactory::repository()->findAll();
+        $service = new ProductService();
+
+        $total = $service->calculateTotal($products);
+
+        self::assertGreaterThan(0, $total);
+    }
+}
+```
+
+### Tests fonctionnels
+```php
+use App\Story\AppStory;
+
+final class ProductControllerTest extends WebTestCase
+{
+    protected function setUp(): void
+    {
+        AppStory::load();
+    }
+
+    public function testListProducts(): void
+    {
+        $client = static::createClient();
+        $client->request('GET', '/products');
+
+        self::assertResponseIsSuccessful();
+        self::assertSelectorExists('.product-item');
+    }
+}
+```
+
+### Fixtures Doctrine
+```bash
+# Charger toutes les fixtures
+php bin/console doctrine:fixtures:load --append
+
+# Ou juste AppStory via attribut #[AsFixture]
+```
+
+## Enrichissement (principe YAGNI)
+
+### Scénarios métier
+```php
+final class ProductStory extends Story implements StoryInterface
+{
+    public function build(): void
+    {
+        // Scénario : catalogue actif
+        ProductFactory::new()
+            ->active()
+            ->createMany(20);
+
+        // Scénario : produits en promotion
+        ProductFactory::new()
+            ->active()
+            ->createMany(5, ['price' => 9.99]);
+
+        // Scénario : rupture de stock
+        ProductFactory::new()
+            ->outOfStock()
+            ->createMany(3);
+
+        // Scénario : nouveau produit vedette
+        ProductFactory::createOne([
+            'name' => 'Featured Product',
+            'price' => 199.99,
+            'stock' => 100,
+            'isActive' => true,
+        ]);
+    }
+}
+```
+
+### Avec relations
+```php
+final class ProductStory extends Story implements StoryInterface
+{
+    public function build(): void
+    {
+        // Charger dépendances
+        CategoryStory::load();
+
+        // Récupérer catégories
+        $electronics = CategoryFactory::find(['name' => 'Electronics']);
+        $books = CategoryFactory::find(['name' => 'Books']);
+
+        // Produits par catégorie
+        ProductFactory::new()
+            ->inCategory($electronics)
+            ->createMany(10);
+
+        ProductFactory::new()
+            ->inCategory($books)
+            ->createMany(15);
+    }
+}
+```
+
+### États nommés
+```php
+final class ProductStory extends Story implements StoryInterface
+{
+    public function build(): void
+    {
+        // États nommés pour réutilisation
+        $this->addState('premium', ProductFactory::createOne([
+            'name' => 'Premium Product',
+            'price' => 999.99,
+        ]));
+
+        $this->addState('cheap', ProductFactory::createOne([
+            'name' => 'Cheap Product',
+            'price' => 9.99,
+        ]));
+
+        $this->addState('test_product', ProductFactory::createOne([
+            'id' => Uuid::fromString('01234567-89ab-cdef-0123-456789abcdef'),
+        ]));
+    }
+}
+
+// Usage
+$premium = ProductStory::load()->get('premium');
+$cheap = ProductStory::load()->get('cheap');
+```
+
+### Scénarios complexes
+```php
+final class OrderStory extends Story implements StoryInterface
+{
+    public function build(): void
+    {
+        // Charger dépendances
+        UserStory::load();
+        ProductStory::load();
+
+        $users = UserFactory::repository()->findAll();
+        $products = ProductFactory::repository()->findAll();
+
+        // Commandes par utilisateur
+        foreach ($users as $user) {
+            OrderFactory::createOne([
+                'user' => $user,
+                'items' => array_slice($products, 0, rand(1, 5)),
+            ]);
+        }
+
+        // Commande de test spécifique
+        $this->addState('test_order', OrderFactory::createOne([
+            'user' => UserStory::load()->get('test_user'),
+            'items' => [ProductStory::load()->get('test_product')],
+            'status' => 'pending',
+        ]));
+    }
+}
+```
+
+## AppStory orchestration
+
+```php
+#[AsFixture(name: 'main')]
+final class AppStory extends Story implements StoryInterface
+{
+    public function build(): void
+    {
+        // Ordre important : dépendances d'abord
+        CategoryStory::load();
+        ProductStory::load();
+        UserStory::load();
+        OrderStory::load();
+        ReviewStory::load();
+    }
+}
+```
+
+## Configuration Foundry
+
+```yaml
+# config/packages/zenstruck_foundry.yaml
+when@dev:
+    zenstruck_foundry:
+        auto_refresh_proxies: false
+
+when@test:
+    zenstruck_foundry:
+        auto_refresh_proxies: false
+        make_factory:
+            default_namespace: 'App\Factory'
+```
+
+## Commandes utiles
+
+```bash
+# Charger fixtures
+php bin/console doctrine:fixtures:load --append
+
+# Purger DB puis charger
+php bin/console doctrine:fixtures:load
+
+# Dans tests
+AppStory::load();
+ProductStory::load();
+```
+
+## Principes Elegant Objects appliqués
+- Classe finale
+- Implements StoryInterface
+- Méthode `build()` claire et concise
+- Scénarios nommés explicitement
+- DRY : fixtures centralisées
+- États nommés pour réutilisation
--- a/skills/make-story/SKILL.md
+++ b/skills/make-story/SKILL.md
@@ -0,0 +1,291 @@
+---
+name: framework:make:story
+description: Génère Story Foundry pour fixtures de tests
+license: MIT
+version: 1.0.0
+---
+
+# Framework Make Story Skill
+
+## Description
+Génère une Story Foundry pour créer des fixtures de tests complexes avec des scénarios prédéfinis.
+
+La Story orchestre la création de multiples instances d'entités via les Factories et permet de charger des jeux de données cohérents pour les tests.
+
+## Usage
+```
+Use skill framework:make:story
+
+Vous serez invité à fournir :
+- Le nom de l'entité (ex: Product, User, Order)
+```
+
+## Templates
+- `Story/UtilisateurStory.php` - Template de story pour une entité
+- `Story/AppStory.php` - Template de story globale (créé si absent)
+
+## Variables requises
+- **{EntityName}** - Nom de l'entité en PascalCase (ex: Utilisateur, Product)
+- **{entityName}** - Nom de l'entité en camelCase (ex: utilisateur, product)
+- **{namespace}** - Namespace du projet (défaut: App)
+
+## Dépendances
+- Requiert que l'entité existe dans `src/Entity/{EntityName}.php`
+- Appelle automatiquement `framework:make:factory` si la Factory n'existe pas
+- Requiert que les Contracts existent (StoryInterface)
+
+## Outputs
+- `src/Story/{EntityName}Story.php`
+- `src/Story/AppStory.php` (si n'existe pas déjà)
+
+## Workflow
+
+1. Demander le nom de l'entité (EntityName)
+2. Vérifier que l'entité existe dans `src/Entity/{EntityName}.php`
+   - Si non : arrêter et demander de créer l'entité d'abord
+3. Vérifier que la Factory existe dans `src/Factory/{EntityName}Factory.php`
+   - Si non : appeler `framework:make:factory`
+4. Générer la Story depuis le template :
+   - Remplacer `{EntityName}` par le nom fourni
+   - Remplacer `{entityName}` par la version camelCase
+5. Vérifier si `src/Story/AppStory.php` existe
+   - Si non : créer AppStory avec le template
+   - Si oui : ajouter `{EntityName}Story::load();` dans la méthode `build()`
+6. Afficher les fichiers créés
+
+## Patterns appliqués
+
+### Classe Story
+- Extends Story
+- Implements StoryInterface
+- Classe `final`
+- Méthode `build()` créant les fixtures
+- Utilise les Factories pour créer les instances
+- Scénarios de tests prédéfinis
+
+### Classe AppStory
+- Extends Story
+- Implements StoryInterface
+- Classe `final`
+- Attribut #[AsFixture(name: 'main')]
+- Méthode `build()` chargeant toutes les stories
+- Point d'entrée unique pour charger toutes les fixtures
+
+## Exemple
+
+```bash
+Use skill framework:make:story
+
+# Saisies utilisateur :
+EntityName: Product
+
+# Résultat :
+✓ src/Story/ProductStory.php
+✓ src/Story/AppStory.php (updated)
+```
+
+Fichiers générés :
+
+```php
+// src/Story/ProductStory.php
+<?php
+
+declare(strict_types=1);
+
+namespace App\Story;
+
+use App\Contracts\Story\StoryInterface;
+use App\Factory\ProductFactory;
+use Zenstruck\Foundry\Story;
+
+final class ProductStory extends Story implements StoryInterface
+{
+    public function build(): void
+    {
+        // Produit par défaut
+        ProductFactory::createOne();
+
+        // Produits avec IDs spécifiques pour les tests
+        ProductFactory::new()
+            ->withSpecificId('01234567-89ab-cdef-0123-456789abcdef')
+            ->create();
+
+        // Créer plusieurs produits
+        ProductFactory::createMany(10);
+    }
+}
+
+// src/Story/AppStory.php
+<?php
+
+namespace App\Story;
+
+use App\Contracts\Story\StoryInterface;
+use Zenstruck\Foundry\Attribute\AsFixture;
+use Zenstruck\Foundry\Story;
+
+#[AsFixture(name: 'main')]
+final class AppStory extends Story implements StoryInterface
+{
+    public function build(): void
+    {
+        ProductStory::load();
+    }
+}
+```
+
+## Usage dans les tests
+
+### Charger la story
+```php
+use App\Story\ProductStory;
+
+final class ProductTest extends TestCase
+{
+    protected function setUp(): void
+    {
+        ProductStory::load();
+    }
+
+    public function testProductsAreLoaded(): void
+    {
+        $products = ProductFactory::repository()->findAll();
+
+        self::assertCount(12, $products); // 1 défaut + 1 spécifique + 10 random
+    }
+}
+```
+
+### Charger toutes les stories
+```php
+use App\Story\AppStory;
+
+final class IntegrationTest extends TestCase
+{
+    protected function setUp(): void
+    {
+        AppStory::load(); // Charge ProductStory + autres
+    }
+}
+```
+
+### Fixture Doctrine
+```bash
+# Dans config/packages/zenstruck_foundry.yaml
+when@dev:
+    zenstruck_foundry:
+        auto_refresh_proxies: false
+
+# Charger les fixtures
+php bin/console doctrine:fixtures:load --append
+```
+
+## Enrichissement de la Story
+
+### Scénarios complexes
+```php
+final class ProductStory extends Story implements StoryInterface
+{
+    public function build(): void
+    {
+        // Produits actifs
+        ProductFactory::new()
+            ->active()
+            ->createMany(5);
+
+        // Produits inactifs
+        ProductFactory::new()
+            ->inactive()
+            ->createMany(3);
+
+        // Produits en rupture
+        ProductFactory::new()
+            ->outOfStock()
+            ->createMany(2);
+
+        // Produits premium
+        ProductFactory::new()
+            ->expensive()
+            ->createMany(3);
+
+        // Produit spécifique pour tests
+        ProductFactory::createOne([
+            'name' => 'Test Product',
+            'price' => 99.99,
+            'stock' => 10,
+        ]);
+    }
+}
+```
+
+### Avec relations
+```php
+final class ProductStory extends Story implements StoryInterface
+{
+    public function build(): void
+    {
+        // Créer catégories d'abord
+        CategoryStory::load();
+
+        $electronics = CategoryFactory::find(['name' => 'Electronics']);
+        $books = CategoryFactory::find(['name' => 'Books']);
+
+        // Produits électroniques
+        ProductFactory::new()
+            ->inCategory($electronics)
+            ->createMany(5);
+
+        // Livres
+        ProductFactory::new()
+            ->inCategory($books)
+            ->createMany(10);
+    }
+}
+```
+
+### Avec états nommés
+```php
+final class ProductStory extends Story implements StoryInterface
+{
+    public function build(): void
+    {
+        // États nommés pour réutilisation dans tests
+        $this->addState('premium_product', ProductFactory::createOne([
+            'name' => 'Premium Product',
+            'price' => 999.99,
+        ]));
+
+        $this->addState('cheap_product', ProductFactory::createOne([
+            'name' => 'Cheap Product',
+            'price' => 9.99,
+        ]));
+    }
+}
+
+// Usage dans test
+$premium = ProductStory::load()->get('premium_product');
+```
+
+## AppStory orchestration
+
+```php
+#[AsFixture(name: 'main')]
+final class AppStory extends Story implements StoryInterface
+{
+    public function build(): void
+    {
+        // Ordre important : dépendances d'abord
+        CategoryStory::load();
+        ProductStory::load();
+        UserStory::load();
+        OrderStory::load();
+    }
+}
+```
+
+## Notes
+- AppStory est le point d'entrée pour charger toutes les fixtures
+- Attribut #[AsFixture(name: 'main')] permet de charger via Doctrine Fixtures
+- Les Stories peuvent avoir des dépendances (charger d'autres Stories)
+- Méthode `addState()` permet de nommer des instances pour les tests
+- Respecte le principe DRY : scénarios centralisés
--- a/skills/make-story/templates/Story/AppStory.php
+++ b/skills/make-story/templates/Story/AppStory.php
@@ -0,0 +1,16 @@
+<?php
+
+namespace App\Story;
+
+use App\Contracts\Story\StoryInterface;
+use Zenstruck\Foundry\Attribute\AsFixture;
+use Zenstruck\Foundry\Story;
+
+#[AsFixture(name: 'main')]
+final class AppStory extends Story implements StoryInterface
+{
+    public function build(): void
+    {
+        UtilisateurStory::load();
+    }
+}
--- a/skills/make-story/templates/Story/UtilisateurStory.php
+++ b/skills/make-story/templates/Story/UtilisateurStory.php
@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Story;
+
+use App\Contracts\Story\StoryInterface;
+use App\Factory\UtilisateurFactory;
+use Zenstruck\Foundry\Story;
+
+final class UtilisateurStory extends Story implements StoryInterface
+{
+    public function build(): void
+    {
+        // Utilisateur par défaut
+        UtilisateurFactory::createOne();
+
+        // Utilisateurs avec IDs spécifiques pour les tests
+        UtilisateurFactory::new()
+            ->withSpecificId('01234567-89ab-cdef-0123-456789abcdef')
+            ->create();
+
+        // Créer plusieurs utilisateurs
+        UtilisateurFactory::createMany(10);
+    }
+}
--- a/skills/make-urls/README.md
+++ b/skills/make-urls/README.md
@@ -0,0 +1,218 @@
+# Framework Make Urls
+
+Génère classe Urls + Message CQRS + Handler pour génération d'URLs.
+
+## Vue d'ensemble
+Cette skill crée un ensemble de classes respectant le pattern CQRS pour gérer la génération d'URLs d'une entité.
+
+## Caractéristiques
+
+### Classes générées
+- **Urls** - Classe finale readonly encapsulant la génération d'URLs
+- **UrlsMessage** - Query CQRS pour récupérer les URLs
+- **UrlsMessageHandler** - Handler orchestrant récupération entité + génération URLs
+
+## Utilisation
+
+```bash
+Use skill framework:make:urls
+```
+
+Vous serez invité à fournir le nom de l'entité.
+
+## Exemple d'utilisation
+
+```bash
+EntityName: Product
+```
+
+Génère 3 fichiers :
+```php
+// src/Urls/ProductUrls.php
+final readonly class ProductUrls
+{
+    private function __construct(
+        private UrlGeneratorInterface $urlGenerator,
+        private Product $product,
+    ) {}
+
+    public static function new(
+        UrlGeneratorInterface $urlGenerator,
+        Product $product,
+    ): self {
+        return new self(
+            urlGenerator: $urlGenerator,
+            product: $product,
+        );
+    }
+}
+
+// src/MessageHandler/ProductUrlsMessage.php
+final class ProductUrlsMessage extends AbstractQueryEvent implements QueryInterface
+{
+    private function __construct(
+        public string $id,
+    ) {}
+
+    public static function new(string $id): self
+    {
+        return new self(id: $id);
+    }
+
+    public function id(): string
+    {
+        return $this->id;
+    }
+}
+
+// src/MessageHandler/ProductUrlsMessageHandler.php
+#[AsMessageHandler]
+final readonly class ProductUrlsMessageHandler
+{
+    public function __construct(
+        private ProductRepositoryInterface $productRepository,
+        private UrlGeneratorInterface $urlGenerator,
+    ) {}
+
+    public function __invoke(ProductUrlsMessage $message): ProductUrls
+    {
+        $product = $this->productRepository->find($message->id());
+        return ProductUrls::new(
+            urlGenerator: $this->urlGenerator,
+            product: $product,
+        );
+    }
+}
+```
+
+## Structure créée
+
+```
+src/
+├── Urls/
+│   └── {EntityName}Urls.php
+└── MessageHandler/
+    ├── {EntityName}UrlsMessage.php
+    └── {EntityName}UrlsMessageHandler.php
+```
+
+## Prérequis
+- L'entité doit exister dans `src/Entity/{EntityName}.php`
+- Le repository doit exister dans `src/Repository/{EntityName}Repository.php`
+- L'interface repository doit exister
+- Symfony Messenger configuré
+- Atournayre packages installés (AbstractQueryEvent, QueryInterface)
+
+## Usage recommandé
+
+### Dans l'entité
+```php
+final class Product implements HasUrlsInterface
+{
+    public function urls(): ProductUrls
+    {
+        /** @var ProductUrls $urls */
+        $urls = ProductUrlsMessage::new(
+            id: $this->id->toRfc4122(),
+        )->query($this->dependencyInjection()->queryBus());
+
+        return $urls;
+    }
+}
+```
+
+### Ajout de méthodes d'URLs
+
+```php
+final readonly class ProductUrls
+{
+    private function __construct(
+        private UrlGeneratorInterface $urlGenerator,
+        private Product $product,
+    ) {}
+
+    public static function new(
+        UrlGeneratorInterface $urlGenerator,
+        Product $product,
+    ): self {
+        return new self(
+            urlGenerator: $urlGenerator,
+            product: $product,
+        );
+    }
+
+    public function show(): string
+    {
+        return $this->urlGenerator->generate(
+            'product_show',
+            ['id' => $this->product->id()->toRfc4122()],
+            UrlGeneratorInterface::ABSOLUTE_URL
+        );
+    }
+
+    public function edit(): string
+    {
+        return $this->urlGenerator->generate(
+            'product_edit',
+            ['id' => $this->product->id()->toRfc4122()],
+            UrlGeneratorInterface::ABSOLUTE_URL
+        );
+    }
+
+    public function api(): string
+    {
+        return $this->urlGenerator->generate(
+            'api_product_get',
+            ['id' => $this->product->id()->toRfc4122()],
+            UrlGeneratorInterface::ABSOLUTE_URL
+        );
+    }
+}
+```
+
+### Utilisation dans templates Twig
+
+```twig
+{# product/show.html.twig #}
+<a href="{{ product.urls.edit }}">Modifier</a>
+<a href="{{ product.urls.delete }}">Supprimer</a>
+
+{# API link #}
+<code>{{ product.urls.api }}</code>
+```
+
+### Utilisation dans contrôleurs
+
+```php
+public function show(Product $product): Response
+{
+    return $this->render('product/show.html.twig', [
+        'product' => $product,
+        'editUrl' => $product->urls()->edit(),
+    ]);
+}
+```
+
+## Architecture CQRS
+
+### Flow
+1. Entité appelle `ProductUrlsMessage::new(id)`
+2. Message envoyé au QueryBus
+3. Handler intercepte le message
+4. Handler récupère l'entité via repository
+5. Handler crée et retourne ProductUrls
+6. URLs disponibles dans l'entité
+
+### Avantages
+- Séparation des responsabilités
+- Testabilité
+- Injection de dépendances propre
+- Pas de service locator dans l'entité
+
+## Principes Elegant Objects appliqués
+- Classes finales
+- Constructeurs privés
+- Factory statiques
+- Immutabilité (readonly)
+- Encapsulation de la logique d'URLs
+- Pas de getters bruts
--- a/skills/make-urls/SKILL.md
+++ b/skills/make-urls/SKILL.md
@@ -0,0 +1,222 @@
+---
+name: framework:make:urls
+description: Génère classe Urls + Message CQRS + Handler
+license: MIT
+version: 1.0.0
+---
+
+# Framework Make Urls Skill
+
+## Description
+Génère une classe Urls pour la génération d'URLs d'une entité, avec le pattern CQRS (Message + MessageHandler).
+
+La classe Urls encapsule la logique de génération d'URLs pour une entité, le Message représente la query CQRS, et le Handler orchestre la récupération de l'entité et la création des URLs.
+
+## Usage
+```
+Use skill framework:make:urls
+
+Vous serez invité à fournir :
+- Le nom de l'entité (ex: Product, User, Order)
+```
+
+## Templates
+- `Urls/UtilisateurUrls.php` - Template de classe Urls
+- `MessageHandler/UtilisateurUrlsMessage.php` - Template de message CQRS
+- `MessageHandler/UtilisateurUrlsMessageHandler.php` - Template de handler
+
+## Variables requises
+- **{EntityName}** - Nom de l'entité en PascalCase (ex: Utilisateur, Product)
+- **{entityName}** - Nom de l'entité en camelCase (ex: utilisateur, product)
+- **{namespace}** - Namespace du projet (défaut: App)
+
+## Dépendances
+- Requiert que l'entité existe dans `src/Entity/{EntityName}.php`
+- Requiert que le repository existe dans `src/Repository/{EntityName}Repository.php`
+- Requiert que l'interface repository existe dans `src/Repository/{EntityName}RepositoryInterface.php`
+
+## Outputs
+- `src/Urls/{EntityName}Urls.php`
+- `src/MessageHandler/{EntityName}UrlsMessage.php`
+- `src/MessageHandler/{EntityName}UrlsMessageHandler.php`
+
+## Workflow
+
+1. Demander le nom de l'entité (EntityName)
+2. Vérifier que l'entité existe dans `src/Entity/{EntityName}.php`
+   - Si non : arrêter et demander de créer l'entité d'abord
+3. Vérifier que le repository existe
+   - Si non : arrêter et demander de créer l'entité avec repository d'abord
+4. Générer les 3 classes depuis les templates :
+   - Remplacer `{EntityName}` par le nom fourni
+   - Remplacer `{entityName}` par la version camelCase
+5. Afficher les fichiers créés
+
+## Patterns appliqués
+
+### Classe Urls
+- Classe `final readonly`
+- Constructeur privé
+- Factory statique `new()`
+- Propriétés : UrlGeneratorInterface + entité
+- Méthodes pour générer URLs spécifiques
+
+### Message CQRS
+- Extends AbstractQueryEvent
+- Implements QueryInterface
+- Classe `final`
+- Constructeur privé avec factory `new()`
+- Propriété publique `id`
+- Méthode getter `id()`
+
+### MessageHandler
+- Classe `final readonly`
+- Attribut #[AsMessageHandler]
+- Constructeur avec repository + UrlGeneratorInterface
+- Méthode `__invoke()` retournant Urls
+
+## Exemple
+
+```bash
+Use skill framework:make:urls
+
+# Saisies utilisateur :
+EntityName: Product
+
+# Résultat :
+✓ src/Urls/ProductUrls.php
+✓ src/MessageHandler/ProductUrlsMessage.php
+✓ src/MessageHandler/ProductUrlsMessageHandler.php
+```
+
+Fichiers générés :
+
+```php
+// src/Urls/ProductUrls.php
+final readonly class ProductUrls
+{
+    private function __construct(
+        private UrlGeneratorInterface $urlGenerator,
+        private Product $product,
+    ) {}
+
+    public static function new(
+        UrlGeneratorInterface $urlGenerator,
+        Product $product,
+    ): self {
+        return new self(
+            urlGenerator: $urlGenerator,
+            product: $product,
+        );
+    }
+}
+
+// src/MessageHandler/ProductUrlsMessage.php
+final class ProductUrlsMessage extends AbstractQueryEvent implements QueryInterface
+{
+    private function __construct(
+        public string $id,
+    ) {}
+
+    public static function new(string $id): self
+    {
+        return new self(id: $id);
+    }
+
+    public function id(): string
+    {
+        return $this->id;
+    }
+}
+
+// src/MessageHandler/ProductUrlsMessageHandler.php
+#[AsMessageHandler]
+final readonly class ProductUrlsMessageHandler
+{
+    public function __construct(
+        private ProductRepositoryInterface $productRepository,
+        private UrlGeneratorInterface $urlGenerator,
+    ) {}
+
+    public function __invoke(ProductUrlsMessage $message): ProductUrls
+    {
+        $product = $this->productRepository->find($message->id());
+        return ProductUrls::new(
+            urlGenerator: $this->urlGenerator,
+            product: $product,
+        );
+    }
+}
+```
+
+## Usage dans l'entité
+
+L'entité doit implémenter la méthode `urls()` :
+
+```php
+public function urls(): ProductUrls
+{
+    /** @var ProductUrls $urls */
+    $urls = ProductUrlsMessage::new(
+        id: $this->id->toRfc4122(),
+    )->query($this->dependencyInjection()->queryBus());
+
+    return $urls;
+}
+```
+
+## Enrichissement avec URLs spécifiques
+
+```php
+final readonly class ProductUrls
+{
+    private function __construct(
+        private UrlGeneratorInterface $urlGenerator,
+        private Product $product,
+    ) {}
+
+    public static function new(
+        UrlGeneratorInterface $urlGenerator,
+        Product $product,
+    ): self {
+        return new self(
+            urlGenerator: $urlGenerator,
+            product: $product,
+        );
+    }
+
+    public function show(): string
+    {
+        return $this->urlGenerator->generate(
+            'product_show',
+            ['id' => $this->product->id()->toRfc4122()],
+            UrlGeneratorInterface::ABSOLUTE_URL
+        );
+    }
+
+    public function edit(): string
+    {
+        return $this->urlGenerator->generate(
+            'product_edit',
+            ['id' => $this->product->id()->toRfc4122()],
+            UrlGeneratorInterface::ABSOLUTE_URL
+        );
+    }
+
+    public function delete(): string
+    {
+        return $this->urlGenerator->generate(
+            'product_delete',
+            ['id' => $this->product->id()->toRfc4122()],
+            UrlGeneratorInterface::ABSOLUTE_URL
+        );
+    }
+}
+```
+
+## Notes
+- Pattern CQRS : séparation query (Message) / handler
+- UrlGeneratorInterface injecté pour génération d'URLs
+- Repository utilisé pour récupérer l'entité par ID
+- Classe Urls peut être enrichie avec méthodes spécifiques au besoin
+- Respecte le principe d'immutabilité (readonly)
--- a/skills/make-urls/templates/MessageHandler/UtilisateurUrlsMessage.php
+++ b/skills/make-urls/templates/MessageHandler/UtilisateurUrlsMessage.php
@@ -0,0 +1,29 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\MessageHandler;
+
+use Atournayre\Common\AbstractQueryEvent;
+use Atournayre\Contracts\CommandBus\QueryInterface;
+
+final class UtilisateurUrlsMessage extends AbstractQueryEvent implements QueryInterface
+{
+    private function __construct(
+        public string $id,
+    ) {
+    }
+
+    public static function new(
+        string $id,
+    ): self {
+        return new self(
+            id: $id,
+        );
+    }
+
+    public function id(): string
+    {
+        return $this->id;
+    }
+}
--- a/skills/make-urls/templates/MessageHandler/UtilisateurUrlsMessageHandler.php
+++ b/skills/make-urls/templates/MessageHandler/UtilisateurUrlsMessageHandler.php
@@ -0,0 +1,30 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\MessageHandler;
+
+use App\Repository\UtilisateurRepositoryInterface;
+use App\Urls\UtilisateurUrls;
+use Symfony\Component\Messenger\Attribute\AsMessageHandler;
+use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
+
+#[AsMessageHandler]
+final readonly class UtilisateurUrlsMessageHandler
+{
+    public function __construct(
+        private UtilisateurRepositoryInterface $utilisateurRepository,
+        private UrlGeneratorInterface $urlGenerator,
+    ) {
+    }
+
+    public function __invoke(UtilisateurUrlsMessage $message): UtilisateurUrls
+    {
+        $utilisateur = $this->utilisateurRepository->find($message->id());
+
+        return UtilisateurUrls::new(
+            urlGenerator: $this->urlGenerator,
+            utilisateur: $utilisateur,
+        );
+    }
+}
--- a/skills/make-urls/templates/Urls/UtilisateurUrls.php
+++ b/skills/make-urls/templates/Urls/UtilisateurUrls.php
@@ -0,0 +1,27 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Urls;
+
+use App\Entity\Utilisateur;
+use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
+
+final readonly class UtilisateurUrls
+{
+    private function __construct(
+        private UrlGeneratorInterface $urlGenerator,
+        private Utilisateur $utilisateur,
+    ) {
+    }
+
+    public static function new(
+        UrlGeneratorInterface $urlGenerator,
+        Utilisateur $utilisateur,
+    ): self {
+        return new self(
+            urlGenerator: $urlGenerator,
+            utilisateur: $utilisateur,
+        );
+    }
+}