@atlashub/smartstack-cli 4.38.0 → 4.40.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlashub/smartstack-cli",
-  "version": "4.38.0",
+  "version": "4.40.0",
   "description": "SmartStack Claude Code automation toolkit - GitFlow, EF Core migrations, prompts and more",
   "author": {
     "name": "SmartStack",

package/templates/agents/efcore/migration.md

@@ -47,6 +47,7 @@ SmartStack uses two separate DbContexts with separate migration histories:
 | `extensions` | ExtensionsDbContext | `extensions` | `extensions.__EFMigrationsHistory` | Client-specific entities |
 
 **Detection Logic:**
+0. If `--context` flag provided → use specified DbContext (skip auto-detection)
 1. If project contains `SmartStack.Domain` → use `CoreDbContext`
 2. If project contains `{ClientName}.Domain` with SmartStack NuGet → use `ExtensionsDbContext`
 3. If unclear → ask user which context to use
@@ -80,6 +81,8 @@ MCP returns the fully compliant name: `{context}_v{version}_{sequence}_{Descript
 
 ## Commands
 
+> **IMPORTANT:** Project detection, migration search, and migration creation should run in a single Bash call to preserve shell variables (`$INFRA_PROJECT`, `$MIGRATIONS_DIR`, `$STARTUP_PROJECT`).
+
 **Prerequisite — ensure `dotnet ef` is on PATH (MANDATORY before any command):**
 
 ```bash
@@ -96,23 +99,29 @@ fi
 > NEVER rely on `$HOME` alone — in WSL it resolves to `/home/{user}` where .NET SDK is absent.
 
 ```bash
+# Detect project paths
+INFRA_PROJECT=$(find src -name "*Infrastructure.csproj" | head -1)
+INFRA_DIR=$(dirname "$INFRA_PROJECT")
+MIGRATIONS_DIR=$(find "$INFRA_DIR" -type d -name "Migrations" -path "*/Persistence/*" | head -1)
+STARTUP_PROJECT=$(find src -name "*.Api.csproj" | head -1)
+
 # Existing migrations for Core
-find Migrations -name "core_*.cs" | grep -v Designer | grep -v Snapshot
+find "$MIGRATIONS_DIR" -name "core_*.cs" | grep -v Designer | grep -v Snapshot
 
 # Existing migrations for Extensions
-find Persistence/Migrations -name "ext_*.cs" | grep -v Designer | grep -v Snapshot
+find "$MIGRATIONS_DIR" -name "ext_*.cs" | grep -v Designer | grep -v Snapshot
 
-# Create Core migration (use MCP_NAME from suggest_migration)
-dotnet ef migrations add $MCP_NAME --context CoreDbContext -o Persistence/Migrations
+# Create Core migration (use MCP_MIGRATION_NAME from suggest_migration)
+dotnet ef migrations add "$MCP_MIGRATION_NAME" --context CoreDbContext -o Persistence/Migrations --project "$INFRA_PROJECT" --startup-project "$STARTUP_PROJECT"
 
-# Create Extensions migration (use MCP_NAME from suggest_migration)
-dotnet ef migrations add $MCP_NAME --context ExtensionsDbContext -o Persistence/Migrations
+# Create Extensions migration (use MCP_MIGRATION_NAME from suggest_migration)
+dotnet ef migrations add "$MCP_MIGRATION_NAME" --context ExtensionsDbContext -o Persistence/Migrations --project "$INFRA_PROJECT" --startup-project "$STARTUP_PROJECT"
 
 # Delete existing migration
-rm Persistence/Migrations/*${OLD_NAME}*.cs
+rm -f "$MIGRATIONS_DIR"/*${OLD_NAME}*.cs
 ```
 
-> **Note:** `$MCP_NAME` is obtained via MCP call, never computed locally.
+> **Note:** `$MCP_MIGRATION_NAME` is obtained via MCP call, never computed locally.
 
 ## SQL Objects (NO injection needed)
 
@@ -186,16 +195,6 @@ After rebase on develop:
 3. Report the error with dotnet output
 4. Suggest corrective action
 
-## SQL in Migrations (STRICT RULE)
-
-**FORBIDDEN:** Raw SQL inline in migrations (e.g., `migrationBuilder.Sql("CREATE FUNCTION ...")`)
-
-**ONLY** SQL objects defined in `src/{Project}.Infrastructure/Persistence/SqlObjects/` are authorized.
-
-- All SQL objects (functions, views, procedures, TVFs) MUST be `.sql` files in `Persistence/SqlObjects/`
-- SQL objects are applied **automatically at startup** via `SqlObjectHelper.ApplyAllAsync()` — no migration injection needed
-- **Never** write raw SQL directly inside migration `Up()` or `Down()` methods
-
 ## Important Notes
 
 - **Core migrations** go to `CoreDbContextModelSnapshot.cs`

package/templates/agents/efcore/rebase-snapshot.md

@@ -21,12 +21,9 @@ if [ -f .git ] && grep -q '^gitdir: [A-Za-z]:' .git 2>/dev/null && grep -qi micr
 fi
 ```
 
-## SQL in Migrations (STRICT RULE)
+## SQL Objects
 
-**FORBIDDEN:** Raw SQL inline in migrations (e.g., `migrationBuilder.Sql("CREATE FUNCTION ...")`)
-
-**ONLY** SQL objects defined in `src/{Project}.Infrastructure/Persistence/SqlObjects/` are authorized.
-SQL objects are applied **automatically at startup** via `SqlObjectHelper.ApplyAllAsync()` — no migration injection needed.
+SQL objects (TVFs, views, SPs) are applied **at startup** via `SqlObjectHelper.ApplyAllAsync()` — never inject in migrations.
 
 ## Workflow
 
@@ -36,42 +33,128 @@ SQL objects are applied **automatically at startup** via `SqlObjectHelper.ApplyA
 4. **Regenerate** consolidated migration
 5. **Validate** build OK
 
+## Shared Functions
+
+> **Reference:** See `references/shared-init-functions.md` for `ensure_dotnet_ef()`, `detect_efcore_project()`, `detect_dbcontext()`, `determine_base_branch()`.
+
 ## Key Commands
 
+> **IMPORTANT:** Steps 1-2 MUST run in a single Bash call to preserve shell variables. Step 2b (confirm) is a separate interactive call. Step 3 requires variables from steps 1-2.
+
+### Step 1: Initialize
+
 ```bash
-# Detect project and DbContext
-detect_efcore_project   # → $DBCONTEXT, $DBCONTEXT_TYPE, $SCHEMA
-determine_base_branch   # → $BASE_BRANCH, $BRANCH_TYPE
+# Determine parent branch
+CURRENT_BRANCH=$(git branch --show-current)
+case "$CURRENT_BRANCH" in
+  feature/*) BASE_BRANCH="develop"; BRANCH_TYPE="feature" ;;
+  release/*) BASE_BRANCH="main";    BRANCH_TYPE="release" ;;
+  hotfix/*)  BASE_BRANCH="main";    BRANCH_TYPE="hotfix" ;;
+  develop)   BASE_BRANCH="main";    BRANCH_TYPE="develop" ;;
+  main|master) echo "BLOCKED: Cannot rebase on main/master"; exit 1 ;;
+  *)         BASE_BRANCH="develop"; BRANCH_TYPE="unknown" ;;
+esac
+
+# Detect project
+INFRA_PROJECT=$(find src -name "*Infrastructure.csproj" | head -1)
+INFRA_DIR=$(dirname "$INFRA_PROJECT")
+MIGRATIONS_DIR=$(find "$INFRA_DIR" -type d -name "Migrations" -path "*/Persistence/*" | head -1)
+MIGRATIONS_REL=$(realpath --relative-to="$(git rev-parse --show-toplevel)" "$MIGRATIONS_DIR")
+STARTUP_PROJECT=$(find src -name "*.Api.csproj" | head -1)
+
+# Detect DbContext (override via --context flag, else auto-detect)
+CONTEXT_OVERRIDE="${CONTEXT:-}"
+if [ "$CONTEXT_OVERRIDE" = "CoreDbContext" ] || [ "$CONTEXT_OVERRIDE" = "core" ]; then
+  DBCONTEXT="CoreDbContext"; DBCONTEXT_TYPE="core"
+elif [ "$CONTEXT_OVERRIDE" = "ExtensionsDbContext" ] || [ "$CONTEXT_OVERRIDE" = "extensions" ]; then
+  DBCONTEXT="ExtensionsDbContext"; DBCONTEXT_TYPE="extensions"
+elif find src -type d -name "SmartStack.Domain" | grep -q .; then
+  DBCONTEXT="CoreDbContext"; DBCONTEXT_TYPE="core"
+else
+  DBCONTEXT="ExtensionsDbContext"; DBCONTEXT_TYPE="extensions"
+fi
+
+echo "Branch: $CURRENT_BRANCH → Base: $BASE_BRANCH"
+echo "Migrations: $MIGRATIONS_DIR"
+echo "DbContext: $DBCONTEXT"
+```
+
+### Step 2: Backup
 
-# Backup
+```bash
 BACKUP_DIR=".claude/gitflow/backup/migrations/rebase_$(date +%Y%m%d_%H%M%S)"
 mkdir -p "$BACKUP_DIR"
-cp Migrations/*.cs "$BACKUP_DIR/"
+cp "$MIGRATIONS_DIR"/*.cs "$BACKUP_DIR/"
+echo "Backup: $BACKUP_DIR"
+```
 
-# Reset snapshot to parent branch (develop or main depending on context)
+### Step 2b: Confirm (skip if `--force`)
+
+If `--force` flag is NOT set:
+
+```javascript
+AskUserQuestion({
+  question: "Rebase snapshot will:\n1. Reset ModelSnapshot to " + BASE_BRANCH + "\n2. Delete branch-specific migrations\n3. Regenerate consolidated migration\n\nBranch-specific migrations to recreate:\n" + BRANCH_ONLY_MIGS + "\n\nProceed?",
+  header: "EF Core Rebase-Snapshot",
+  options: [
+    { label: "Yes, rebase", description: "Backup + rebase snapshot" },
+    { label: "Cancel", description: "Do nothing" }
+  ]
+})
+```
+
+### Step 3: Identify branch-specific migrations + Reset
+
+```bash
 git fetch origin "$BASE_BRANCH"
-git checkout "origin/$BASE_BRANCH" -- Migrations/*ModelSnapshot.cs
+
+# List parent branch migrations (names only)
+BASE_MIGS=$(git ls-tree -r --name-only "origin/$BASE_BRANCH" -- "$MIGRATIONS_REL/" 2>/dev/null | grep "\.cs$" | grep -v "Designer\|Snapshot" | xargs -I{} basename {} .cs)
+
+# List local migrations (names only)
+LOCAL_MIGS=$(find "$MIGRATIONS_DIR" -maxdepth 1 -name "*.cs" ! -name "*Designer*" ! -name "*Snapshot*" | xargs -I{} basename {} .cs)
+
+# Calculate branch-specific migrations (in local but NOT in base)
+BRANCH_ONLY_MIGS=""
+for mig in $LOCAL_MIGS; do
+  if ! echo "$BASE_MIGS" | grep -qx "$mig"; then
+    BRANCH_ONLY_MIGS="$BRANCH_ONLY_MIGS $mig"
+  fi
+done
+BRANCH_ONLY_MIGS=$(echo "$BRANCH_ONLY_MIGS" | xargs)
+
+echo "Branch-specific migrations to recreate:"
+for mig in $BRANCH_ONLY_MIGS; do echo "  - $mig"; done
+
+# Reset snapshot to parent branch
+git checkout "origin/$BASE_BRANCH" -- "$MIGRATIONS_REL"/*ModelSnapshot.cs
 
 # Retrieve parent branch migrations
-BASE_MIGS=$(git ls-tree -r --name-only "origin/$BASE_BRANCH" -- Migrations/ | grep "\.cs$" | grep -v "Designer\|Snapshot")
 for base_mig in $BASE_MIGS; do
-  base_name=$(basename "${base_mig%.cs}")
-  git checkout "origin/$BASE_BRANCH" -- "Migrations/${base_name}.cs" 2>/dev/null || true
-  git checkout "origin/$BASE_BRANCH" -- "Migrations/${base_name}.Designer.cs" 2>/dev/null || true
+  git checkout "origin/$BASE_BRANCH" -- "$MIGRATIONS_REL/${base_mig}.cs" 2>/dev/null || true
+  git checkout "origin/$BASE_BRANCH" -- "$MIGRATIONS_REL/${base_mig}.Designer.cs" 2>/dev/null || true
+done
+
+# Delete branch-specific migrations by exact name (NOT by branch type pattern)
+for mig in $BRANCH_ONLY_MIGS; do
+  rm -f "$MIGRATIONS_DIR"/*"${mig}"*.cs
+  echo "  Deleted: $mig"
 done
+```
 
-# Delete branch migrations only
-rm -f Migrations/*${BRANCH_TYPE}_*.cs
-rm -f Migrations/*${BRANCH_TYPE}_*.Designer.cs
+### Step 4: Regenerate + Validate
 
+```bash
 # Regenerate with MCP naming - MANDATORY
 mcp__smartstack__suggest_migration({ description: "...", context: DBCONTEXT_TYPE })
-# Result: core_v1.7.0_001_UserAuthConsolidated
 
-dotnet ef migrations add "$MIGRATION_NAME" --context "$DBCONTEXT"
+dotnet ef migrations add "$MCP_MIGRATION_NAME" \
+  --context "$DBCONTEXT" \
+  --project "$INFRA_PROJECT" \
+  --startup-project "$STARTUP_PROJECT" \
+  -o Persistence/Migrations
 
-# NOTE: SQL objects (TVFs, views, SPs) are applied automatically at startup
-# via SqlObjectHelper.ApplyAllAsync() — no injection needed in migrations.
+# NOTE: SQL objects are applied automatically at startup — no injection needed.
 
 # Validate
 dotnet build

package/templates/agents/efcore/squash.md

@@ -21,12 +21,9 @@ if [ -f .git ] && grep -q '^gitdir: [A-Za-z]:' .git 2>/dev/null && grep -qi micr
 fi
 ```
 
-## SQL in Migrations (STRICT RULE)
+## SQL Objects
 
-**FORBIDDEN:** Raw SQL inline in migrations (e.g., `migrationBuilder.Sql("CREATE FUNCTION ...")`)
-
-**ONLY** SQL objects defined in `src/{Project}.Infrastructure/Persistence/SqlObjects/` are authorized.
-SQL objects are applied **automatically at startup** via `SqlObjectHelper.ApplyAllAsync()` — no migration injection needed.
+SQL objects (TVFs, views, SPs) are applied **at startup** via `SqlObjectHelper.ApplyAllAsync()` — never inject in migrations.
 
 ## Core Principle
 
@@ -53,57 +50,158 @@ WARNING: NEVER retrieve only the snapshot without the migrations!
 7. **Create**: Create consolidated migration (MCP mandatory)
 8. **Validate**: Build + script OK
 
+## Shared Functions
+
+> **Reference:** See `references/shared-init-functions.md` for `ensure_dotnet_ef()`, `detect_efcore_project()`, `detect_dbcontext()`, `determine_base_branch()`, `block_production()`.
+
 ## Key Commands
 
+> **IMPORTANT:** Steps 1-3 MUST run in a single Bash call to preserve shell variables ($BASE_BRANCH, $MIGRATIONS_DIR, $BRANCH_ONLY_MIGS, etc.). Step 4 (guard) and Step 5 (confirm) are separate calls. Step 6 requires variables from steps 1-3.
+
+### Step 1: Initialize
+
 ```bash
-# Determine parent branch and DbContext
-determine_base_branch   # → BASE_BRANCH, BRANCH_TYPE
-detect_efcore_project   # → $DBCONTEXT, $DBCONTEXT_TYPE, $SCHEMA
+# Determine parent branch
+CURRENT_BRANCH=$(git branch --show-current)
+case "$CURRENT_BRANCH" in
+  feature/*) BASE_BRANCH="develop"; BRANCH_TYPE="feature" ;;
+  release/*) BASE_BRANCH="main";    BRANCH_TYPE="release" ;;
+  hotfix/*)  BASE_BRANCH="main";    BRANCH_TYPE="hotfix" ;;
+  develop)   BASE_BRANCH="main";    BRANCH_TYPE="develop" ;;
+  main|master) echo "BLOCKED: Cannot squash on main/master"; exit 1 ;;
+  *)         BASE_BRANCH="develop"; BRANCH_TYPE="unknown" ;;
+esac
+echo "Branch: $CURRENT_BRANCH ($BRANCH_TYPE) → Base: $BASE_BRANCH"
+
+# Context override from --context flag (passed via agent prompt)
+CONTEXT_OVERRIDE="${CONTEXT:-}"
+```
 
-# Identify branch-specific migrations
-BASE_MIGS=$(git ls-tree -r --name-only "origin/$BASE_BRANCH" -- Migrations/ | grep "\.cs$" | grep -v "Designer\|Snapshot")
-LOCAL_MIGS=$(find Migrations -name "*.cs" | grep -v Designer | grep -v Snapshot)
+### Step 2: Detect project and migrations directory
 
+```bash
+# Find Infrastructure project and migrations directory
+INFRA_PROJECT=$(find src -name "*Infrastructure.csproj" | head -1)
+INFRA_DIR=$(dirname "$INFRA_PROJECT")
+MIGRATIONS_DIR=$(find "$INFRA_DIR" -type d -name "Migrations" -path "*/Persistence/*" | head -1)
+
+# Detect DbContext (override via --context flag, else auto-detect)
+if [ "$CONTEXT_OVERRIDE" = "CoreDbContext" ] || [ "$CONTEXT_OVERRIDE" = "core" ]; then
+  DBCONTEXT="CoreDbContext"; DBCONTEXT_TYPE="core"
+elif [ "$CONTEXT_OVERRIDE" = "ExtensionsDbContext" ] || [ "$CONTEXT_OVERRIDE" = "extensions" ]; then
+  DBCONTEXT="ExtensionsDbContext"; DBCONTEXT_TYPE="extensions"
+elif find src -type d -name "SmartStack.Domain" | grep -q .; then
+  DBCONTEXT="CoreDbContext"; DBCONTEXT_TYPE="core"
+else
+  DBCONTEXT="ExtensionsDbContext"; DBCONTEXT_TYPE="extensions"
+fi
+
+echo "Migrations: $MIGRATIONS_DIR"
+echo "DbContext: $DBCONTEXT"
+```
+
+### Step 3: Identify branch-specific migrations
+
+```bash
+git fetch origin "$BASE_BRANCH"
+
+# Get migration file paths RELATIVE TO GIT ROOT
+MIGRATIONS_REL=$(realpath --relative-to="$(git rev-parse --show-toplevel)" "$MIGRATIONS_DIR")
+
+# List parent branch migrations (names only, no Designer/Snapshot)
+BASE_MIGS=$(git ls-tree -r --name-only "origin/$BASE_BRANCH" -- "$MIGRATIONS_REL/" 2>/dev/null | grep "\.cs$" | grep -v "Designer\|Snapshot" | xargs -I{} basename {} .cs)
+
+# List local migrations (names only)
+LOCAL_MIGS=$(find "$MIGRATIONS_DIR" -maxdepth 1 -name "*.cs" ! -name "*Designer*" ! -name "*Snapshot*" | xargs -I{} basename {} .cs)
+
+# Calculate branch-specific migrations (in local but NOT in base)
+BRANCH_ONLY_MIGS=""
+for mig in $LOCAL_MIGS; do
+  if ! echo "$BASE_MIGS" | grep -qx "$mig"; then
+    BRANCH_ONLY_MIGS="$BRANCH_ONLY_MIGS $mig"
+  fi
+done
+BRANCH_ONLY_MIGS=$(echo "$BRANCH_ONLY_MIGS" | xargs)  # trim
+
+BRANCH_COUNT=$(echo "$BRANCH_ONLY_MIGS" | wc -w)
+BASE_COUNT=$(echo "$BASE_MIGS" | wc -w)
+
+echo ""
+echo "Parent ($BASE_BRANCH): $BASE_COUNT migration(s)"
+echo "Branch-specific: $BRANCH_COUNT migration(s)"
+for mig in $BRANCH_ONLY_MIGS; do echo "  - $mig"; done
+```
+
+### Step 4: Guard — nothing to squash
+
+```bash
+if [ "$BRANCH_COUNT" -eq 0 ]; then
+  echo "Nothing to squash — no branch-specific migrations found."
+  exit 0
+fi
+if [ "$BRANCH_COUNT" -eq 1 ]; then
+  echo "Only 1 branch-specific migration — squash not needed."
+  exit 0
+fi
+```
+
+### Step 5: Confirm (skip if `--force`)
+
+If `--force` flag is NOT set, display the plan and ask confirmation:
+
+```javascript
+AskUserQuestion({
+  question: "Squash will consolidate " + BRANCH_COUNT + " migrations into 1.\n\nMigrations to squash:\n" + BRANCH_ONLY_MIGS_LIST + "\n\nParent: " + BASE_BRANCH + " (" + BASE_COUNT + " migrations will be preserved)\n\nProceed?",
+  header: "EF Core Squash",
+  options: [
+    { label: "Yes, squash", description: "Backup + consolidate" },
+    { label: "Cancel", description: "Do nothing" }
+  ]
+})
+```
+
+### Step 6: Backup + Fetch + Delete + Create
+
+```bash
 # Backup
 BACKUP_DIR=".claude/gitflow/backup/migrations/squash_$(date +%Y%m%d_%H%M%S)"
-mkdir -p "$BACKUP_DIR" && cp Migrations/*.cs "$BACKUP_DIR/"
+mkdir -p "$BACKUP_DIR" && cp "$MIGRATIONS_DIR"/*.cs "$BACKUP_DIR/"
+echo "Backup: $BACKUP_DIR"
 
 # ═══════════════════════════════════════════════════════════════════════════
 # CRUCIAL: Retrieve SNAPSHOT + MIGRATIONS from parent branch
 # ═══════════════════════════════════════════════════════════════════════════
-git fetch origin "$BASE_BRANCH"
 
 # 1. Retrieve ModelSnapshot
-git checkout "origin/$BASE_BRANCH" -- Migrations/*ModelSnapshot.cs
+git checkout "origin/$BASE_BRANCH" -- "$MIGRATIONS_REL"/*ModelSnapshot.cs
 echo "Snapshot retrieved from origin/$BASE_BRANCH"
 
 # 2. Retrieve ALL migrations from parent branch
-# MANDATORY: Without this, develop/main migrations will be lost!
 for base_mig in $BASE_MIGS; do
-  base_name=$(basename "${base_mig%.cs}")
-  git checkout "origin/$BASE_BRANCH" -- "Migrations/${base_name}.cs" 2>/dev/null || true
-  git checkout "origin/$BASE_BRANCH" -- "Migrations/${base_name}.Designer.cs" 2>/dev/null || true
-  echo "  $base_name retrieved"
+  git checkout "origin/$BASE_BRANCH" -- "$MIGRATIONS_REL/${base_mig}.cs" 2>/dev/null || true
+  git checkout "origin/$BASE_BRANCH" -- "$MIGRATIONS_REL/${base_mig}.Designer.cs" 2>/dev/null || true
 done
-echo "$(echo "$BASE_MIGS" | wc -l) migrations retrieved from origin/$BASE_BRANCH"
+echo "$BASE_COUNT migration(s) retrieved from origin/$BASE_BRANCH"
 
-# Delete branch-specific migrations only
-for mig in $BRANCH_ONLY_MIGRATIONS; do
-  rm -f "Migrations/${mig}"*
+# 3. Delete branch-specific migrations only
+for mig in $BRANCH_ONLY_MIGS; do
+  rm -f "$MIGRATIONS_DIR"/*"${mig}"*.cs
+  echo "  Deleted: $mig"
 done
 
-# Create consolidated migration - MCP MANDATORY
-# $DBCONTEXT_TYPE = "core" or "extensions" (from detect_efcore_project)
+# 4. Create consolidated migration - MCP MANDATORY
 mcp__smartstack__suggest_migration({ description: "...", context: DBCONTEXT_TYPE })
-# Result: core_v1.9.0_001_Description
-
-dotnet ef migrations add "$MIGRATION_NAME_FROM_MCP" --context "$DBCONTEXT"
+# Use the name returned by MCP in $MCP_MIGRATION_NAME:
+dotnet ef migrations add "$MCP_MIGRATION_NAME" \
+  --context "$DBCONTEXT" \
+  --project "$INFRA_PROJECT" \
+  --startup-project "$(find src -name "*.Api.csproj" | head -1)" \
+  -o Persistence/Migrations
 
-# NOTE: SQL objects (TVFs, views, SPs) are applied automatically at startup
-# via SqlObjectHelper.ApplyAllAsync() — no injection needed in migrations.
+# NOTE: SQL objects are applied automatically at startup — no injection needed.
 
-# Validate
-dotnet build && dotnet ef migrations script --idempotent > /dev/null
+# 5. Validate
+dotnet build && dotnet ef migrations script --idempotent --context "$DBCONTEXT" > /dev/null
 ```
 
 ## Safety Checks
@@ -130,7 +228,7 @@ SQUASH - {current_branch}
 
   Consolidated:
     Before: {M} migrations (branch-specific)
-    After:  1 migration ({MIGRATION_NAME} via MCP)
+    After:  1 migration ({MCP_MIGRATION_NAME} via MCP)
 
   Backup: .claude/gitflow/backup/migrations/squash_{timestamp}/
 

package/templates/agents/gitflow/cleanup.md

@@ -43,9 +43,9 @@ fi
 | Categorie | Condition | Action |
 |-----------|-----------|--------|
 | Permanent | main, develop | Protege - jamais supprime |
-| Actif | Branche existe + recent | Conserver |
-| Orphelin | Branche supprimee | Supprimer |
-| Stale | Inactif > 30 jours | Proposer suppression |
+| Actif | Branche existe + non mergee + recent | Conserver |
+| Orphelin | Repertoire manquant ou branche supprimee | Supprimer (worktree + local + remote + parent dir) |
+| Stale | Remote supprime OU branche mergee dans develop/main | Supprimer (worktree + local + remote + parent dir) |
 | Dirty | Modifications non commitees | Warning - confirmation requise |
 
 ## Commandes
@@ -64,9 +64,20 @@ git branch --list $BRANCH
 # Derniere activite
 git log -1 --format=%ci $BRANCH
 
-# Supprimer worktree
-git worktree remove "$WORKTREE_PATH" --force
-git worktree prune
+# Supprimer worktree (3 etapes obligatoires)
+git worktree remove "$WORKTREE_PATH" --force   # 1. Remove worktree
+git push origin --delete "$BRANCH" 2>/dev/null  # 2. Delete remote branch
+git branch -D "$BRANCH" 2>/dev/null             # 3. Delete local branch
+git worktree prune                              # 4. Prune stale refs
+```
+
+## Post-cleanup: empty parent directories
+
+```bash
+# Remove empty parent directories (features/, releases/, hotfixes/)
+for dir in "$FEATURES_DIR" "$RELEASES_DIR" "$HOTFIXES_DIR"; do
+  [ -d "$dir" ] && [ -z "$(ls -A "$dir" 2>/dev/null)" ] && rm -rf "$dir"
+done
 ```
 
 ## Output Format

package/templates/skills/dev-start/SKILL.md

@@ -3,7 +3,7 @@ name: dev-start
 description: Launch SmartStack dev environment (backend + frontend + admin credentials)
 argument-hint: "[--stop] [--reset] [--backend-only] [--frontend-only]"
 model: haiku
-allowed-tools: Read, Bash, Glob, Write
+allowed-tools: Read, Bash, Glob, Write, TaskOutput
 ---
 
 ## Arguments
@@ -106,9 +106,11 @@ If `--stop` argument → skip this step entirely (--stop uses netstat only).
 
 **Skip if CACHE_HIT=true (values loaded from cache in Step 0).**
 
-Find the API and Web directories:
-- API: `src/*.Api` (first match)
-- Web: `web/*-web` (first match)
+Find the API and Web directories using bash (Glob doesn't match directories):
+```bash
+API_DIR=$(ls -d src/*.Api 2>/dev/null | head -1)
+WEB_DIR=$(ls -d web/*-web 2>/dev/null | head -1)
+```
 
 If neither found, display error and exit.
 
@@ -129,6 +131,11 @@ Check if `appsettings.Local.json` exists in the API directory:
 - **Dev backend port**: Default `5142`
 - **Dev frontend port**: Default `6173`
 
+**IMPORTANT: Read config files in parallel.** Use a single message with multiple Read tool calls for:
+- `{API_DIR}/appsettings.json` (or `appsettings.Local.json`)
+- `{WEB_DIR}/.env.development` (or `.env.standalone`)
+- `{API_DIR}/Properties/launchSettings.json`
+
 ## Step 3: Validate config coherence
 
 **Skip if CACHE_HIT=true (values loaded from cache in Step 0).**
@@ -242,7 +249,7 @@ Config Coherence Check:
 3. Write `.claude/config/dev-run.json` using the Write tool with all detected values:
    ```json
    {
-     "version": 1,
+     "version": 2,
      "api_dir": "{API_DIR}",
      "web_dir": "{WEB_DIR}",
      "mode": "{MODE}",
@@ -250,6 +257,7 @@ Config Coherence Check:
      "web_port": {WEB_PORT},
      "backend_cmd": "{BACKEND_CMD}",
      "frontend_cmd": "{FRONTEND_CMD}",
+     "connection_string": "{CONN_STR}",
      "sql_server": "{SQL_SERVER}",
      "sql_database": "{SQL_DATABASE}",
      "sql_status": "{ok|unreachable|db_missing|skipped}",
@@ -270,14 +278,29 @@ If `--frontend-only`: skip backend checks.
 
 ## Step 5: Launch backend
 
-If NOT already running and NOT `--frontend-only`:
+Track whether the backend was just launched: `BACKEND_JUST_LAUNCHED=true/false`. This is used in Step 7 for cache invalidation.
+
+If NOT already running and NOT `--frontend-only` (set `BACKEND_JUST_LAUNCHED=true`):
 
 ```bash
 # cd into the API directory first
 cd {API_DIR} && dotnet run {LAUNCH_ARGS}
 ```
 
-Use `Bash(run_in_background=true)` so it runs in background.
+Use `Bash(run_in_background=true)` so it runs in background. **Save the task ID** returned by the background command.
+
+### Fail-fast crash detection
+
+After launching, wait 5 seconds then check if the process crashed:
+```bash
+sleep 5
+```
+Then call `TaskOutput(task_id="{TASK_ID}", block=false)` to read the background output.
+
+**If the output contains a stack trace, "Unhandled exception", or the process has already exited:**
+1. Display the error output to the user
+2. Display: `[FAIL] Backend crashed on startup. Fix the error above and retry /dev-start`
+3. **STOP immediately. Do NOT attempt to diagnose, fix, rebuild, or retry.**
 
 ## Step 6: Launch frontend
 
@@ -292,27 +315,33 @@ Use `Bash(run_in_background=true)` so it runs in background.
 
 ## Step 7: Handle admin password
 
-1. If `.claude/dev-session.json` exists and contains a password and `--reset` NOT specified -> reuse stored credentials
-2. If `--reset` OR no stored password:
-   a. If backend was just launched, wait for it to be UP first:
+**Cache invalidation rule:** If the backend was just launched in Step 5 (i.e., it was NOT already running), the cache is STALE because `MigrateAsync()` + `HasData()` may have re-seeded the admin user with the default password hash, overwriting any previously set password. In this case, ALWAYS run a fresh admin reset regardless of `dev-session.json`.
+
+1. If `.claude/dev-session.json` exists and contains a password AND `--reset` NOT specified AND the backend was already running (NOT launched in Step 5) -> reuse stored credentials
+2. If `--reset` OR no stored password OR backend was just launched in Step 5:
+   a. If backend was just launched, wait for it to be UP first.
+      Run the full wait in a **single bash command** to avoid multiple tool calls:
       ```bash
       # Phase 1: Wait for port to be bound (up to 30s)
+      echo "Waiting for backend port ${API_PORT}..."
       for i in $(seq 1 10); do
-        netstat.exe -ano | grep ":${API_PORT} .*LISTENING" && break
+        netstat.exe -ano | grep ":${API_PORT} .*LISTENING" > /dev/null 2>&1 && echo "Port bound." && break
         sleep 3
       done
-      ```
-      ```bash
-      # Phase 2: Wait for API to actually respond to HTTP requests (up to 30s)
-      # Kestrel binds the port BEFORE the app is fully initialized.
-      # We must confirm the API actually responds before resetting the password.
+      # Phase 2: Wait for API to respond (up to 30s) — accept 200 or 302
+      echo "Waiting for API to respond..."
       for i in $(seq 1 10); do
-        curl -s -o /dev/null -w "%{http_code}" "http://localhost:${API_PORT}/scalar" 2>/dev/null | grep -q "200" && break
+        HTTP_CODE=$(curl -s -o /dev/null -w "%{http_code}" "http://localhost:${API_PORT}/scalar" 2>/dev/null)
+        [ "$HTTP_CODE" = "200" ] || [ "$HTTP_CODE" = "302" ] && echo "API ready (HTTP $HTTP_CODE)." && break
         sleep 3
       done
       ```
-      If `/scalar` does not return 200 after 30s, warn the user and attempt the reset anyway.
-   b. Run: `smartstack admin reset --force --json`
+      If `/scalar` does not respond after 30s, warn the user and attempt the reset anyway.
+   b. Run admin reset using the connection string extracted from appsettings (Step 3):
+      ```bash
+      smartstack admin reset --connection '{CONN_STR}' --force --json
+      ```
+      **IMPORTANT:** Always pass `--connection` with the full connection string (single-quoted to avoid shell expansion). Without it, the CLI shows an interactive environment picker that blocks execution.
    c. Parse JSON output to extract email and password
    d. Write `.claude/dev-session.json`:
       ```json
@@ -352,14 +381,18 @@ Use `Bash(run_in_background=true)` so it runs in background.
 
 <important_notes>
 
-1. **Backend must be READY before admin reset** - First poll the port (netstat), then poll the `/health` endpoint (HTTP 200) to confirm the API is fully initialized. Kestrel binds the port before the app finishes starting, so port-only checks are insufficient.
-2. **Cross-worktree support** - Detect the correct API directory regardless of which worktree we're in
-3. **No MCP required** - This skill only uses bash commands and the `smartstack` CLI
-4. **Config coherence is critical** - Mismatched ports between backend/frontend is the #1 cause of "it doesn't work" issues
-5. **Idempotent** - Running twice should detect already-running processes and reuse stored credentials
-6. **dev-session.json contains secrets** - Must be in `.gitignore`
-7. **Cache** - Config detection is cached in `.claude/config/dev-run.json`. Cache is invalidated when config files change (mtime-based hash). Use `--reset` to force re-detection.
-8. **SQL check is non-blocking** - A failed SQL check displays a warning but does not prevent launch. AutoMigrate may create the database on startup.
+1. **NEVER debug or fix code** - This skill ONLY starts processes. If the backend or frontend fails to start, display the error and STOP. Do NOT attempt to: clean/restore/rebuild, upgrade packages, inspect DLLs, clear NuGet cache, read .csproj files, or any other diagnostic/repair action. The user will fix the issue themselves.
+2. **Fail-fast on crash** - After launching backend in background, wait 5s then check TaskOutput. If the process already exited or shows errors, report and STOP immediately.
+3. **Backend must be READY before admin reset** - First poll the port (netstat), then poll the `/scalar` endpoint (HTTP 200/302) to confirm the API is fully initialized. Kestrel binds the port before the app finishes starting, so port-only checks are insufficient.
+4. **Admin reset requires --connection** - Always pass `--connection '{CONN_STR}'` (single-quoted to avoid shell expansion) to avoid the interactive environment picker.
+5. **Read config files in parallel** - When reading appsettings, .env, and launchSettings, use multiple Read calls in a single message.
+6. **Cross-worktree support** - Detect the correct API directory regardless of which worktree we're in.
+7. **No MCP required** - This skill only uses bash commands and the `smartstack` CLI.
+8. **Config coherence is critical** - Mismatched ports between backend/frontend is the #1 cause of "it doesn't work" issues.
+9. **Idempotent** - Running twice should detect already-running processes and reuse stored credentials.
+10. **dev-session.json contains secrets** - Must be in `.gitignore`.
+11. **Cache** - Config detection is cached in `.claude/config/dev-run.json`. Cache is invalidated when config files change (mtime-based hash). Use `--reset` to force re-detection.
+12. **SQL check is non-blocking** - A failed SQL check displays a warning but does not prevent launch. AutoMigrate may create the database on startup.
 
 </important_notes>