@atlashub/smartstack-cli 1.11.0 → 1.13.1

package/templates/commands/gitflow/11-finish.md

@@ -6,559 +6,370 @@ model: sonnet
 
 # Phase 11: FINISH - Finaliser une branche GitFlow
 
-Tu es expert GitFlow. Finalise une branche apres merge de la PR.
+**Argument:** `$ARGUMENTS` = branche (optionnel, SCAN si absent)
 
-**Argument:** `$ARGUMENTS` = branche a finaliser (optionnel, **SCAN AUTOMATIQUE** si absent)
+> **IMPORTANT:** Cette commande EXECUTE les opérations automatiquement. Ne PAS afficher les commandes bash à l'utilisateur - les EXECUTER directement via l'outil Bash.
+
+> **Ref:** Fonctions dans [_shared.md](_shared.md)
+> **Ref:** Fonction `determine_base_branch()` dans [efcore/_shared.md](../efcore/_shared.md)
 
 ---
 
-## Quand utiliser
+## MODE D'EXÉCUTION
+
+**CRITIQUE:** Tu dois EXECUTER chaque commande avec l'outil Bash, pas les afficher.
 
-| Situation | Action |
-|-----------|--------|
-| PR feature mergee | Cleanup uniquement |
-| PR release mergee | Tag + merge back to develop |
-| PR hotfix mergee | Tag + merge back to develop |
+Workflow:
+1. Détecter le contexte (worktree, branche, PR)
+2. Exécuter les opérations silencieusement
+3. Afficher uniquement le RÉSUMÉ final
 
 ---
 
-## ETAPE 0: SYNCHRONISATION AVEC REMOTE
+## Étape 0: Détection du contexte
 
-> **CRITIQUE:** Toujours synchroniser avec le remote avant toute opération de finish.
+**EXECUTER:**
 
 ```bash
-echo "Synchronisation avec remote..."
+# Aller au repo principal si dans un worktree
+MAIN_WORKTREE=$(git worktree list --porcelain | grep -m1 "^worktree " | sed 's/worktree //')
+cd "$MAIN_WORKTREE"
+
+# Synchroniser
 git fetch --all --quiet
+```
 
-# Vérifier l'état de synchronisation des branches principales
-echo ""
-echo "État des branches principales:"
+---
 
-# Vérifier develop
-DEVELOP_BEHIND=$(git rev-list --count develop..origin/develop 2>/dev/null || echo "?")
-DEVELOP_AHEAD=$(git rev-list --count origin/develop..develop 2>/dev/null || echo "?")
-echo "  develop: AHEAD=$DEVELOP_AHEAD, BEHIND=$DEVELOP_BEHIND"
+## Étape 1: Scan Proactif (si pas d'argument)
 
-# Vérifier main
-MAIN_BEHIND=$(git rev-list --count main..origin/main 2>/dev/null || echo "?")
-MAIN_AHEAD=$(git rev-list --count origin/main..main 2>/dev/null || echo "?")
-echo "  main:    AHEAD=$MAIN_AHEAD, BEHIND=$MAIN_BEHIND"
+Si `$ARGUMENTS` est vide, scanner les branches avec PR mergées:
 
-# Avertissement si branches principales non synchronisées
-if [ "$DEVELOP_BEHIND" != "0" ] && [ "$DEVELOP_BEHIND" != "?" ]; then
-  echo "⚠️ develop est en retard de $DEVELOP_BEHIND commit(s) - sera mis à jour automatiquement"
-fi
-if [ "$MAIN_BEHIND" != "0" ] && [ "$MAIN_BEHIND" != "?" ]; then
-  echo "⚠️ main est en retard de $MAIN_BEHIND commit(s) - sera mis à jour automatiquement"
-fi
+**EXECUTER:**
+
+```bash
+# Lister branches avec PR mergée (prêtes à finaliser)
+for BRANCH in $(git branch -r | grep -E 'origin/(feature|release|hotfix)/' | sed 's/origin\///'); do
+  PR_MERGED=$(gh pr list --head "$BRANCH" --state merged --json number --jq '.[0].number' 2>/dev/null)
+  [ -n "$PR_MERGED" ] && echo "✅ $BRANCH (PR #$PR_MERGED mergée)"
+done
 ```
 
----
+Puis demander à l'utilisateur quelle branche finaliser.
 
-## ETAPE 1: SCAN PROACTIF (si pas d'argument)
+---
 
-> **COMPORTEMENT PROACTIF:** Si aucun argument fourni, scanner TOUTES les branches pour proposer celles qui sont pretes a finaliser.
+## Étape 2: Vérifier état de la PR
 
-### 1.1 Scanner toutes les branches GitFlow
+**EXECUTER:**
 
 ```bash
-# Note: git fetch déjà effectué dans ETAPE 0
-
-# Lister toutes les branches feature/release/hotfix
-FEATURES=$(git branch -r | grep 'origin/feature/' | sed 's|origin/||' | tr -d ' ')
-RELEASES=$(git branch -r | grep 'origin/release/' | sed 's|origin/||' | tr -d ' ')
-HOTFIXES=$(git branch -r | grep 'origin/hotfix/' | sed 's|origin/||' | tr -d ' ')
+BRANCH="$1"  # Argument fourni ou sélectionné
 
-ALL_BRANCHES="$FEATURES $RELEASES $HOTFIXES"
-```
+# Vérifier si PR mergée
+PR_INFO=$(gh pr list --head "$BRANCH" --state merged --json number,mergedAt --jq '.[0]')
 
-### 1.2 Verifier le statut PR de chaque branche
+if [ -z "$PR_INFO" ]; then
+  # PR pas trouvée comme mergée - vérifier si main a les commits
+  git checkout main --quiet && git pull origin main --quiet
 
-```bash
-# Pour chaque branche, verifier:
-for BRANCH in $ALL_BRANCHES; do
-  # 1. PR mergee?
-  PR_MERGED=$(gh pr list --head "$BRANCH" --state merged --json number,mergedAt --jq '.[0]')
-
-  # 2. PR ouverte?
-  PR_OPEN=$(gh pr list --head "$BRANCH" --state open --json number,url --jq '.[0]')
-
-  # 3. Pas de PR?
-  # Si pas de PR → suggerer /gitflow:7-pull-request
-
-  # Categoriser
-  if [ -n "$PR_MERGED" ]; then
-    READY_TO_FINISH+=("$BRANCH")
-  elif [ -n "$PR_OPEN" ]; then
-    WAITING_FOR_MERGE+=("$BRANCH")
+  # Vérifier si la branche existe encore
+  if ! git show-ref --verify --quiet "refs/remotes/origin/$BRANCH"; then
+    echo "✓ Branche déjà supprimée sur remote - PR probablement mergée via GitHub"
   else
-    NEEDS_PR+=("$BRANCH")
+    echo "⚠️ PR non trouvée comme mergée"
+    exit 1
   fi
-done
+fi
 ```
 
-### 1.3 Afficher le tableau de synthese
+---
 
-```
-================================================================================
-                    GITFLOW FINISH - SCAN DES BRANCHES
-================================================================================
-
-✅ PRETES A FINALISER (PR mergee):
-┌─────────────────────────────┬───────────┬────────────┬─────────────────────┐
-│ Branche                     │ Type      │ PR #       │ Mergee le           │
-├─────────────────────────────┼───────────┼────────────┼─────────────────────┤
-│ feature/add-user-auth       │ feature   │ #42        │ 2024-01-15 14:30    │
-│ release/v1.5.0              │ release   │ #45        │ 2024-01-15 16:00    │
-└─────────────────────────────┴───────────┴────────────┴─────────────────────┘
-
-⏳ EN ATTENTE DE MERGE (PR ouverte):
-┌─────────────────────────────┬───────────┬────────────┬─────────────────────┐
-│ Branche                     │ Type      │ PR #       │ Statut              │
-├─────────────────────────────┼───────────┼────────────┼─────────────────────┤
-│ feature/add-orders          │ feature   │ #43        │ Review en cours     │
-│ hotfix/fix-login            │ hotfix    │ #44        │ CI en cours         │
-└─────────────────────────────┴───────────┴────────────┴─────────────────────┘
-
-❌ SANS PR (action requise):
-┌─────────────────────────────┬───────────┬────────────────────────────────────┐
-│ Branche                     │ Type      │ Action suggeree                    │
-├─────────────────────────────┼───────────┼────────────────────────────────────┤
-│ feature/wip-refactor        │ feature   │ /gitflow:7-pull-request            │
-│ feature/old-abandoned       │ feature   │ /gitflow:6-abort --branch          │
-└─────────────────────────────┴───────────┴────────────────────────────────────┘
-
-================================================================================
-```
+## Étape 2.5: Vérification EF Core Post-Merge Manuel (CRITIQUE)
 
-### 1.4 Proposition interactive
-
-```javascript
-// Si plusieurs branches pretes a finaliser
-if (READY_TO_FINISH.length > 0) {
-  AskUserQuestion({
-    questions: [{
-      question: "Quelle branche voulez-vous finaliser ?",
-      header: "Finish",
-      options: READY_TO_FINISH.map(branch => ({
-        label: branch,
-        description: `PR #${getPRNumber(branch)} mergee - ${getType(branch)}`
-      })).concat([{
-        label: "Toutes",
-        description: "Finaliser toutes les branches pretes (dans l'ordre recommande)"
-      }]),
-      multiSelect: false
-    }]
-  })
-} else if (WAITING_FOR_MERGE.length > 0) {
-  // Afficher message d'aide
-  console.log("Aucune branche prete a finaliser.")
-  console.log("→ Attendez le merge des PRs en cours ou utilisez /gitflow:9-merge")
-} else if (NEEDS_PR.length > 0) {
-  // Afficher message d'aide
-  console.log("Aucune branche prete. Creez d'abord une PR:")
-  console.log("→ /gitflow:7-pull-request")
-}
-```
+**Contexte:** Si la PR a été mergée manuellement (via GitHub/Azure DevOps UI), les checks EF Core de `/gitflow:9-merge` n'ont pas été exécutés. Cette étape rattrape cette vérification.
 
-### 1.5 Ordre recommande pour "Toutes"
+**EXECUTER:**
 
-```
-ORDRE DE FINALISATION RECOMMANDE:
-  1. Hotfixes (urgents, vers main puis develop)
-  2. Releases (vers main puis develop)
-  3. Features (vers develop, par date de merge)
-```
+```bash
+# Déterminer la branche cible selon le type
+case "$BRANCH" in
+  feature/*|bugfix/*) TARGET_BRANCH="develop" ;;
+  release/*|hotfix/*) TARGET_BRANCH="main" ;;
+esac
 
----
+# Vérifier si le projet a des migrations EF Core
+MIGRATIONS_DIR=$(find . -type d -name "Migrations" 2>/dev/null | head -1)
 
-## ETAPE 2: Detecter le contexte (si argument fourni)
+if [ -n "$MIGRATIONS_DIR" ] && [ -d "$MIGRATIONS_DIR" ]; then
+  echo "Vérification EF Core post-merge..."
 
-```bash
-# Branche specifiee ou selectionnee
-BRANCH=${ARGUMENTS:-$SELECTED_BRANCH}
-
-# Determiner le type
-if [[ $BRANCH == feature/* ]]; then TYPE="feature"
-elif [[ $BRANCH == release/* ]]; then TYPE="release"
-elif [[ $BRANCH == hotfix/* ]]; then TYPE="hotfix"
-else
-  echo "⚠️ '$BRANCH' n'est pas une branche GitFlow (feature/release/hotfix)"
-  echo "→ Utilisez /gitflow:11-finish sans argument pour scanner les branches"
-  exit 1
-fi
-```
+  git checkout "$TARGET_BRANCH" --quiet && git pull origin "$TARGET_BRANCH" --quiet
 
-## ETAPE 3: Verifier que PR est mergee
+  EF_CHECK_FAILED=""
 
-```bash
-# Chercher PR associee
-PR_INFO=$(gh pr list --head "$BRANCH" --state merged --json number,mergedAt,title --jq '.[0]')
+  # 1. Vérifier que le build passe
+  if ! dotnet build --no-restore --verbosity quiet 2>/dev/null; then
+    echo "❌ ERREUR: Build échoue sur $TARGET_BRANCH après merge"
+    echo "→ Possible conflit de migrations non résolu"
+    EF_CHECK_FAILED=true
+  fi
 
-# Si pas mergee
-if [ -z "$PR_INFO" ]; then
-  # Verifier si PR ouverte
-  PR_OPEN=$(gh pr list --head "$BRANCH" --state open --json number,url --jq '.[0]')
+  # 2. Vérifier que les migrations sont listables
+  if ! dotnet ef migrations list --no-build 2>/dev/null | tail -1 | grep -q "Done\|applied"; then
+    echo "⚠️ WARNING: Problème avec les migrations EF Core"
+    EF_CHECK_FAILED=true
+  fi
+
+  # 3. Vérifier pas de markers de conflit Git dans les fichiers
+  if grep -rq "<<<<<<\|>>>>>>\|======" "$MIGRATIONS_DIR" 2>/dev/null; then
+    echo "❌ ERREUR: Conflits Git non résolus dans $MIGRATIONS_DIR"
+    EF_CHECK_FAILED=true
+  fi
 
-  if [ -n "$PR_OPEN" ]; then
-    PR_NUM=$(echo "$PR_OPEN" | jq -r '.number')
-    echo "⚠️ PR #$PR_NUM existe mais n'est pas encore mergee"
+  # 4. Pour release/hotfix: info sur divergence develop
+  if [[ "$BRANCH" =~ ^(release|hotfix)/ ]]; then
+    MAIN_COUNT=$(git ls-tree -r --name-only origin/main -- "$MIGRATIONS_DIR" 2>/dev/null | grep -c "\.cs$" || echo "0")
+    DEV_COUNT=$(git ls-tree -r --name-only origin/develop -- "$MIGRATIONS_DIR" 2>/dev/null | grep -c "\.cs$" || echo "0")
+
+    [ "$DEV_COUNT" -gt "$MAIN_COUNT" ] && \
+      echo "ℹ️ develop a $((DEV_COUNT - MAIN_COUNT)) migration(s) de plus que main (normal si features en cours)"
+  fi
+
+  if [ -n "$EF_CHECK_FAILED" ]; then
     echo ""
-    echo "Options:"
-    echo "  1. Merger la PR:     /gitflow:9-merge $PR_NUM"
-    echo "  2. Voir la PR:       gh pr view $PR_NUM --web"
-    echo "  3. Abandonner:       /gitflow:6-abort --branch"
+    echo "┌─────────────────────────────────────────────────────────────┐"
+    echo "│  PROBLÈME EF CORE DÉTECTÉ APRÈS MERGE MANUEL                │"
+    echo "│                                                             │"
+    echo "│  Commandes de diagnostic:                                   │"
+    echo "│    /efcore:db-status       - État des migrations            │"
+    echo "│    /efcore:conflicts       - Analyser les conflits          │"
+    echo "│    /efcore:rebase-snapshot - Resync si snapshot diverge     │"
+    echo "└─────────────────────────────────────────────────────────────┘"
+    # Ne pas bloquer, continuer avec le finish mais alerter
   else
-    echo "⚠️ Aucune PR trouvee pour '$BRANCH'"
-    echo ""
-    echo "Options:"
-    echo "  1. Creer une PR:     /gitflow:7-pull-request"
-    echo "  2. Abandonner:       /gitflow:6-abort --branch"
+    echo "✓ EF Core: Migrations OK sur $TARGET_BRANCH"
   fi
-  exit 1
 fi
 ```
 
 ---
 
-## Actions selon type
-
-### Feature (simple cleanup)
-
-```bash
-# Detecter si on est dans un worktree et trouver le repo principal
-CURRENT_DIR=$(pwd)
-MAIN_WORKTREE=$(git worktree list --porcelain | grep -m1 "^worktree " | sed 's/worktree //')
-
-# Revenir au repo principal AVANT de supprimer le worktree
-cd "$MAIN_WORKTREE"
+## Actions par type
 
-# Supprimer worktree si existe
-WORKTREE_PATH="../worktrees/features/{name}"
-if [ -d "$WORKTREE_PATH" ]; then
-  git worktree remove "$WORKTREE_PATH" --force 2>/dev/null || true
-fi
+### Feature
 
-# Supprimer branche locale
-git checkout develop
-git pull origin develop
-git branch -d feature/{name}
+**EXECUTER ces commandes dans l'ordre:**
 
-# Supprimer branche remote (si pas fait par merge)
-git push origin --delete feature/{name} 2>/dev/null || true
+1. Checkout develop et pull:
+```bash
+git checkout develop && git pull origin develop
 ```
 
-**Resume:**
+2. Supprimer branche locale:
+```bash
+git branch -d "$BRANCH" 2>/dev/null || git branch -D "$BRANCH" 2>/dev/null
+```
 
+3. Supprimer branche remote (si existe):
+```bash
+git push origin --delete "$BRANCH" 2>/dev/null || true
 ```
-═══════════════════════════════════════════════════════════════════════════════
-                         FEATURE FINALISÉE
-═══════════════════════════════════════════════════════════════════════════════
-
-FINISH DETAILS
-───────────────────────────────────────────────────────────────────────────────
-  • Type:      feature
-  • Branche:   feature/{name}
-  • Mergée:    develop
-  • PR:        #{number}
-
-WORKFLOW STATUT
-───────────────────────────────────────────────────────────────────────────────
-  ✓ PR #{number} mergée avec succès
-  ✓ Branche feature/{name} supprimée (local)
-  ✓ Branche feature/{name} supprimée (remote)
-  ✓ Worktree nettoyé
-
-═══════════════════════════════════════════════════════════════════════════════
-                         PROCHAINES ÉTAPES
-═══════════════════════════════════════════════════════════════════════════════
-
-1. Créer une nouvelle feature:
-   /gitflow:10-start feature {name}
-
-2. Créer une release (si prêt pour production):
-   /gitflow:10-start release
-
-3. Voir le statut du repo:
-   /gitflow:2-status
-
-═══════════════════════════════════════════════════════════════════════════════
+
+4. Cleanup worktree:
+```bash
+# Détecter et nettoyer le worktree
+WORKTREE_PATH=""
+case "$BRANCH" in
+  feature/*)
+    [ -d "../features/${BRANCH#feature/}" ] && WORKTREE_PATH="../features/${BRANCH#feature/}"
+    [ -d "../worktrees/features/${BRANCH#feature/}" ] && WORKTREE_PATH="../worktrees/features/${BRANCH#feature/}"
+    ;;
+esac
+[ -n "$WORKTREE_PATH" ] && [ -d "$WORKTREE_PATH" ] && {
+  git worktree remove "$WORKTREE_PATH" --force 2>/dev/null || rm -rf "$WORKTREE_PATH"
+  git worktree prune
+}
 ```
 
 ---
 
-### Release (tag + merge back)
+### Release
 
-```bash
-# 0. Detecter si on est dans un worktree et trouver le repo principal
-CURRENT_DIR=$(pwd)
-MAIN_WORKTREE=$(git worktree list --porcelain | grep -m1 "^worktree " | sed 's/worktree //')
+**EXECUTER ces commandes dans l'ordre:**
 
-# Revenir au repo principal AVANT toute operation
-cd "$MAIN_WORKTREE"
+1. Checkout main et pull (récupérer le merge de la PR):
+```bash
+git checkout main && git pull origin main
+```
 
-# 1. Checkout main et pull
-git checkout main
-git pull origin main
+2. Extraire la version:
+```bash
+VERSION=$(echo "$BRANCH" | sed 's/release\/v\?//')
+```
 
-# 2. Creer tag
-VERSION=$(echo $BRANCH | sed 's/release\/v//')
-git tag -a "v$VERSION" -m "Release v$VERSION"
-git push origin "v$VERSION"
+3. Créer le tag (si pas déjà existant):
+```bash
+if ! git tag -l "v$VERSION" | grep -q "v$VERSION"; then
+  git tag -a "v$VERSION" -m "Release v$VERSION"
+  git push origin "v$VERSION"
+fi
+```
 
-# 3. Merge back to develop
-git checkout develop
-git pull origin develop
+4. Merge back vers develop:
+```bash
+git checkout develop && git pull origin develop
 git merge main --no-ff -m "chore: merge release v$VERSION back to develop"
+```
 
-# 4. AUTO-INCREMENT MINOR VERSION sur develop (prepare next release)
-# Ceci evite que les futures features utilisent la meme version que la release
-CURRENT_VERSION=$(cat package.json | jq -r '.version')
-
-# Calculer la prochaine version MINOR (ex: 1.2.0 -> 1.3.0)
-NEXT_VERSION=$(node -e "
-  const [major, minor, patch] = '$CURRENT_VERSION'.split('.').map(Number);
-  console.log([major, minor + 1, 0].join('.'));
-")
-
-# Mettre a jour package.json avec la nouvelle version
-npm version $NEXT_VERSION --no-git-tag-version
-
-# Committer le bump de version
-git add package.json package-lock.json
-git commit -m "chore: bump develop to v$NEXT_VERSION for next release"
+4.5. **Vérifier propagation migrations (CRITIQUE):**
+```bash
+# Comparer migrations main vs develop après merge
+MAIN_MIGRATIONS=$(git ls-tree -r --name-only origin/main -- Migrations/ | grep "\.cs$" | grep -v "Designer\|Snapshot" | wc -l)
+DEV_MIGRATIONS=$(find Migrations -name "*.cs" | grep -v "Designer\|Snapshot" | wc -l)
 
-git push origin develop
+if [ "$DEV_MIGRATIONS" -lt "$MAIN_MIGRATIONS" ]; then
+  echo "⚠️ ATTENTION: develop a moins de migrations que main"
+  echo "→ Vérifier le merge des migrations"
+fi
 
-echo "OK Version develop incrementee: $CURRENT_VERSION -> $NEXT_VERSION"
+# Vérifier que le snapshot develop inclut tout de main
+git diff origin/main -- Migrations/*ModelSnapshot.cs
+# Si diff significatif → conflit de migrations à résoudre
+```
 
-# 5. Cleanup worktree + branche
-WORKTREE_PATH="../worktrees/releases/v$VERSION"
-if [ -d "$WORKTREE_PATH" ]; then
-  git worktree remove "$WORKTREE_PATH" --force 2>/dev/null || true
+5. Auto-incrémenter MINOR pour develop:
+```bash
+# Trouver package.json (web ou racine)
+PKG_PATH=$(find . -name "package.json" -not -path "*/node_modules/*" | head -1)
+if [ -n "$PKG_PATH" ]; then
+  CURRENT=$(cat "$PKG_PATH" | grep -oP '"version":\s*"\K[^"]+')
+  NEXT=$(echo "$CURRENT" | awk -F. '{print $1"."$2+1".0"}')
+  cd "$(dirname "$PKG_PATH")"
+  npm version "$NEXT" --no-git-tag-version
+  cd -
+  git add "$PKG_PATH"
+  [ -f "${PKG_PATH%.json}-lock.json" ] && git add "${PKG_PATH%.json}-lock.json"
+  git commit -m "chore: bump develop to v$NEXT for next release"
 fi
-git branch -d release/v$VERSION
-git push origin --delete release/v$VERSION 2>/dev/null || true
+git push origin develop
 ```
 
-**Resume:**
-
-```
-═══════════════════════════════════════════════════════════════════════════════
-                         RELEASE FINALISÉE
-═══════════════════════════════════════════════════════════════════════════════
-
-RELEASE DETAILS
-───────────────────────────────────────────────────────────────────────────────
-  • Type:      release
-  • Branche:   release/v{version}
-  • Version:   v{version}
-  • Tag:       v{version} ✓
-
-VERSIONING
-───────────────────────────────────────────────────────────────────────────────
-  • Release:   v{version} → Déployée sur main
-  • Develop:   {version} → {NEXT_VERSION} (auto-incrémenté)
-
-WORKFLOW STATUT
-───────────────────────────────────────────────────────────────────────────────
-  ✓ PR mergée sur main
-  ✓ Tag v{version} créé et poussé
-  ✓ Main mis à jour
-  ✓ Merge back vers develop effectué
-  ✓ Version develop incrémentée ({version} → {NEXT_VERSION})
-  ✓ Branche release/{version} supprimée
-  ✓ Worktree nettoyé
-
-═══════════════════════════════════════════════════════════════════════════════
-                         PROCHAINES ÉTAPES
-═══════════════════════════════════════════════════════════════════════════════
-
-✅ Release v{version} déployée avec succès!
-
-1. Créer une nouvelle feature:
-   /gitflow:10-start feature {name}
-
-2. Créer un hotfix (si besoin):
-   /gitflow:10-start hotfix {name}
-
-3. Voir le statut du repo:
-   /gitflow:2-status
-
-═══════════════════════════════════════════════════════════════════════════════
+6. Cleanup:
+```bash
+git branch -d "$BRANCH" 2>/dev/null || git branch -D "$BRANCH" 2>/dev/null
+git push origin --delete "$BRANCH" 2>/dev/null || true
+
+WORKTREE_PATH=""
+[ -d "../releases/${BRANCH#release/}" ] && WORKTREE_PATH="../releases/${BRANCH#release/}"
+[ -d "../releases/v${VERSION}" ] && WORKTREE_PATH="../releases/v${VERSION}"
+[ -d "../worktrees/releases/${VERSION}" ] && WORKTREE_PATH="../worktrees/releases/${VERSION}"
+[ -n "$WORKTREE_PATH" ] && [ -d "$WORKTREE_PATH" ] && {
+  git worktree remove "$WORKTREE_PATH" --force 2>/dev/null || rm -rf "$WORKTREE_PATH"
+  git worktree prune
+}
 ```
 
 ---
 
-### Hotfix (auto-increment PATCH + tag + merge back)
+### Hotfix
 
-```bash
-# 0. Detecter si on est dans un worktree et trouver le repo principal
-CURRENT_DIR=$(pwd)
-MAIN_WORKTREE=$(git worktree list --porcelain | grep -m1 "^worktree " | sed 's/worktree //')
+**EXECUTER ces commandes dans l'ordre:**
 
-# Revenir au repo principal AVANT toute operation
-cd "$MAIN_WORKTREE"
-
-# 1. Checkout main et pull
-git checkout main
-git pull origin main
-
-# 2. AUTO-INCREMENT PATCH VERSION
-# Lire la version actuelle
-CURRENT_VERSION=$(cat package.json | jq -r '.version')
-
-# Calculer la nouvelle version (PATCH increment)
-# Ex: 1.7.1 → 1.7.2
-NEW_VERSION=$(node -e "
-  const [major, minor, patch] = '$CURRENT_VERSION'.split('.').map(Number);
-  console.log([major, minor, patch + 1].join('.'));
-")
-
-# Mettre a jour package.json avec la nouvelle version
-npm version $NEW_VERSION --no-git-tag-version
+1. Checkout main et pull:
+```bash
+git checkout main && git pull origin main
+```
 
-# Committer le bump de version
-git add package.json package-lock.json
+2. Auto-incrémenter PATCH:
+```bash
+PKG_PATH=$(find . -name "package.json" -not -path "*/node_modules/*" | head -1)
+CURRENT=$(cat "$PKG_PATH" | grep -oP '"version":\s*"\K[^"]+')
+NEW_VERSION=$(echo "$CURRENT" | awk -F. '{print $1"."$2"."$3+1}')
+cd "$(dirname "$PKG_PATH")"
+npm version "$NEW_VERSION" --no-git-tag-version
+cd -
+git add "$PKG_PATH"
+[ -f "${PKG_PATH%.json}-lock.json" ] && git add "${PKG_PATH%.json}-lock.json"
 git commit -m "chore: bump version to $NEW_VERSION"
+```
 
-# 3. Creer tag avec la nouvelle version
+3. Créer tag et push:
+```bash
 git tag -a "v$NEW_VERSION" -m "Hotfix v$NEW_VERSION"
-git push origin main
-git push origin "v$NEW_VERSION"
+git push origin main "v$NEW_VERSION"
+```
 
-# 4. Merge back to develop
-git checkout develop
-git pull origin develop
+4. Merge back vers develop:
+```bash
+git checkout develop && git pull origin develop
 git merge main --no-ff -m "chore: merge hotfix v$NEW_VERSION back to develop"
-git push origin develop
-
-# 6. Cleanup worktree + branche
-WORKTREE_PATH="../worktrees/hotfixes/{name}"
-if [ -d "$WORKTREE_PATH" ]; then
-  git worktree remove "$WORKTREE_PATH" --force 2>/dev/null || true
-fi
-git branch -d hotfix/{name}
-git push origin --delete hotfix/{name} 2>/dev/null || true
 ```
 
-**⚠️ IMPORTANT:** Le bump de version PATCH est automatique. Pas besoin de le faire manuellement avant le finish.
+4.5. **Vérifier propagation migrations (CRITIQUE):**
+```bash
+# Vérifier que le snapshot develop inclut les changements du hotfix
+git diff origin/main -- Migrations/*ModelSnapshot.cs
+# Si diff significatif → conflit de migrations à résoudre manuellement
 
-**Resume:**
+# En cas de conflit:
+# 1. Récupérer snapshot main (état production)
+# 2. Régénérer migration develop si nécessaire
+```
 
+```bash
+git push origin develop
 ```
-═══════════════════════════════════════════════════════════════════════════════
-                         HOTFIX FINALISÉ
-═══════════════════════════════════════════════════════════════════════════════
-
-HOTFIX DETAILS
-───────────────────────────────────────────────────────────────────────────────
-  • Type:      hotfix
-  • Branche:   hotfix/{name}
-  • Correction: {description}
-
-VERSIONING
-───────────────────────────────────────────────────────────────────────────────
-  • Avant:     v{CURRENT_VERSION}
-  • Après:     v{NEW_VERSION} (PATCH auto-incrémenté)
-  • Tag:       v{NEW_VERSION} ✓
-
-WORKFLOW STATUT
-───────────────────────────────────────────────────────────────────────────────
-  ✓ Version incrémentée (PATCH): {CURRENT_VERSION} → {NEW_VERSION}
-  ✓ package.json mis à jour
-  ✓ Tag v{NEW_VERSION} créé et poussé
-  ✓ Main mis à jour
-  ✓ Merge back vers develop effectué
-  ✓ Branche hotfix/{name} supprimée
-  ✓ Worktree nettoyé
-
-═══════════════════════════════════════════════════════════════════════════════
-                         PROCHAINES ÉTAPES
-═══════════════════════════════════════════════════════════════════════════════
-
-✅ Hotfix v{NEW_VERSION} déployé avec succès!
-
-1. Créer une nouvelle feature:
-   /gitflow:10-start feature {name}
-
-2. Créer une release:
-   /gitflow:10-start release
-
-3. Voir le statut du repo:
-   /gitflow:2-status
-
-═══════════════════════════════════════════════════════════════════════════════
+
+5. Cleanup:
+```bash
+git branch -d "$BRANCH" 2>/dev/null || git branch -D "$BRANCH" 2>/dev/null
+git push origin --delete "$BRANCH" 2>/dev/null || true
+
+WORKTREE_PATH=""
+[ -d "../hotfixes/${BRANCH#hotfix/}" ] && WORKTREE_PATH="../hotfixes/${BRANCH#hotfix/}"
+[ -d "../worktrees/hotfixes/${BRANCH#hotfix/}" ] && WORKTREE_PATH="../worktrees/hotfixes/${BRANCH#hotfix/}"
+[ -n "$WORKTREE_PATH" ] && [ -d "$WORKTREE_PATH" ] && {
+  git worktree remove "$WORKTREE_PATH" --force 2>/dev/null || rm -rf "$WORKTREE_PATH"
+  git worktree prune
+}
 ```
 
 ---
 
-## Gestion des conflits (merge back)
-
-Si conflit lors du merge back to develop :
+## Résumé (AFFICHER à la fin)
 
 ```
-⚠️ CONFLIT DETECTE - MERGE BACK
-────────────────────────────────
-Le merge de main vers develop a des conflits.
-
-Fichiers en conflit:
-{liste fichiers}
-
-Options:
-1. Resoudre manuellement puis: git merge --continue
-2. Annuler: git merge --abort
-
-Commande recommandee:
-  Resoudre conflits dans IDE
-  git add .
-  git merge --continue
-  git push origin develop
-────────────────────────────────
+{TYPE} FINALISÉ ✓
+- Branche: {branch}
+- PR: #{number} (mergée)
+- Tag: {v1.2.3|N/A}
+- Merge back develop: {done|N/A}
+- Version develop: {NEXT_VERSION|unchanged}
+- Worktree: nettoyé
 ```
 
----
-
-## Cleanup automatique des worktrees
-
-Apres chaque finish, un cleanup cible est effectue pour le worktree de la branche finalisee:
-
-```bash
-# Fonction de cleanup cible (appelee automatiquement)
-cleanup_worktree_for_branch() {
-  BRANCH=$1
-  WORKTREE_BASE="../worktrees"
-
-  # Determiner le chemin selon le type
-  if [[ $BRANCH == feature/* ]]; then
-    NAME=${BRANCH#feature/}
-    WORKTREE_PATH="$WORKTREE_BASE/features/$NAME"
-  elif [[ $BRANCH == release/* ]]; then
-    VERSION=${BRANCH#release/}
-    WORKTREE_PATH="$WORKTREE_BASE/releases/$VERSION"
-  elif [[ $BRANCH == hotfix/* ]]; then
-    NAME=${BRANCH#hotfix/}
-    WORKTREE_PATH="$WORKTREE_BASE/hotfixes/$NAME"
-  fi
+**PROCHAINE ÉTAPE**
 
-  # Supprimer si existe
-  if [ -d "$WORKTREE_PATH" ]; then
-    git worktree remove "$WORKTREE_PATH" --force 2>/dev/null || true
-    rm -rf "$WORKTREE_PATH" 2>/dev/null || true
-    git worktree prune
-    echo "✓ Worktree nettoye: $WORKTREE_PATH"
-  fi
-}
+Démarrer une nouvelle feature:
 
-# Appel automatique
-cleanup_worktree_for_branch "$BRANCH"
+```
+/gitflow:10-start feature {name}
 ```
 
-**Note:** Pour un audit complet de tous les worktrees, utilisez:
+---
 
-```
-/gitflow:12-cleanup
-```
+## Gestion des erreurs
+
+| Erreur | Action |
+|--------|--------|
+| PR non mergée | `⚠️ Merger la PR d'abord: /gitflow:9-merge` |
+| Conflit merge back | Résoudre puis: `git add . && git merge --continue && git push` |
+| Tag existe déjà | Skip création tag, continuer |
+| Branche déjà supprimée | Continuer avec cleanup worktree |
+| Build échoue post-merge | `/efcore:db-status` puis `/efcore:conflicts` |
+| Conflits Git dans migrations | Résoudre manuellement puis `/efcore:rebase-snapshot` |
+| Snapshot désynchronisé | `/efcore:rebase-snapshot` sur la branche cible |
 
 ---
 
@@ -566,7 +377,6 @@ cleanup_worktree_for_branch "$BRANCH"
 
 | Commande | Action |
 |----------|--------|
-| `/gitflow:11-finish` | Finaliser branche courante |
-| `/gitflow:11-finish feature/xxx` | Finaliser branche specifiee |
-| `/gitflow:11-finish --dry-run` | Simulation |
-| `/gitflow:11-finish --skip-tag` | Sans creation de tag |
+| `/gitflow:11-finish` | Scan et proposer branches prêtes |
+| `/gitflow:11-finish feature/xxx` | Finaliser branche spécifique |
+| `/gitflow:11-finish --skip-tag` | Sans créer de tag |