@atlashub/smartstack-cli 4.37.0 → 4.39.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlashub/smartstack-cli",
-  "version": "4.37.0",
+  "version": "4.39.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,66 +99,35 @@ 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.
-
-## SQL Objects Post-Injection (MANDATORY after every migration creation)
+> **Note:** `$MCP_MIGRATION_NAME` is obtained via MCP call, never computed locally.
 
-**This step is NON-OPTIONAL.** After EVERY `dotnet ef migrations add`, you MUST check for SQL objects and inject them into the generated migration. Skipping this step causes runtime 500 errors on ALL endpoints (TVFs like `fn_GetUserGroupHierarchy` won't exist in the database).
+## SQL Objects (NO injection needed)
 
-```bash
-# Detect the generated migration file (the main .cs, not .Designer.cs)
-MIGRATION_FILE=$(find "$MIGRATIONS_DIR" -name "*${MCP_NAME}.cs" ! -name "*.Designer.cs" | head -1)
-SQL_OBJECTS_DIR="$INFRA_PROJECT_DIR/Persistence/SqlObjects"
-SQL_FILES=$(find "$SQL_OBJECTS_DIR" -name "*.sql" 2>/dev/null | wc -l)
-
-if [ "$SQL_FILES" -gt 0 ]; then
-  echo "Found $SQL_FILES SQL object(s) — injecting SqlObjectHelper.ApplyAll()..."
-
-  # Add using directive if not present
-  if ! grep -q "using SmartStack.Infrastructure.Persistence.SqlObjects;" "$MIGRATION_FILE"; then
-    sed -i '1s/^/using SmartStack.Infrastructure.Persistence.SqlObjects;\n/' "$MIGRATION_FILE"
-  fi
-
-  # Add SqlObjectHelper.ApplyAll at the end of Up() method
-  # Use Edit tool to insert before the closing brace of Up()
-  # Target: the last "        }" before "protected override void Down"
-  sed -i '/protected override void Down/i\
-\            // Apply SQL objects (TVF, Views, SP) from embedded resources\
-\            SqlObjectHelper.ApplyAll(migrationBuilder);' "$MIGRATION_FILE"
-
-  # VERIFY injection succeeded — FAIL if not
-  if ! grep -q "SqlObjectHelper.ApplyAll" "$MIGRATION_FILE"; then
-    echo "ERROR: Auto-injection failed. Use Edit tool to manually add:"
-    echo "  1. Add 'using SmartStack.Infrastructure.Persistence.SqlObjects;' at top"
-    echo "  2. Add 'SqlObjectHelper.ApplyAll(migrationBuilder);' at end of Up() method"
-    echo "  File: $MIGRATION_FILE"
-    # DO NOT CONTINUE — fix this before proceeding
-  else
-    echo "  SqlObjectHelper.ApplyAll(migrationBuilder) injected successfully"
-    find "$SQL_OBJECTS_DIR" -name "*.sql" -exec basename {} \; | while read f; do echo "  - $f"; done
-  fi
-else
-  echo "No SQL objects found in SqlObjects/ — skipping injection"
-fi
-```
+SQL objects (TVFs, views, stored procedures) are applied **automatically at application startup** via `SqlObjectHelper.ApplyAllAsync(dbContext)` in `SmartStackExtensions.InitializeSmartStackAsync()`, right after `MigrateAsync()`.
 
-> **CRITICAL:** If the bash `sed` injection fails (indentation mismatch), use the **Edit tool** to manually insert the lines. NEVER skip this step — it causes cascading 500 errors at runtime.
+**You do NOT need to add `SqlObjectHelper.ApplyAll(migrationBuilder)` in migrations.** The startup process handles this with `CREATE OR ALTER` (idempotent). Modifying a `.sql` file only requires an application restart — no new migration needed.
 
 ## Context Detection
 
@@ -223,17 +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/`
-- Migrations reference these via `SqlObjectHelper.ApplyAll(migrationBuilder)` in the `Up()` method
-- If `Persistence/SqlObjects/*.sql` files exist, inject the call automatically after migration creation
-- **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.
-Migrations reference these via `SqlObjectHelper.ApplyAll(migrationBuilder)` — never inline SQL.
+SQL objects (TVFs, views, SPs) are applied **at startup** via `SqlObjectHelper.ApplyAllAsync()` — never inject in migrations.
 
 ## Workflow
 
@@ -36,75 +33,128 @@ Migrations reference these via `SqlObjectHelper.ApplyAll(migrationBuilder)` —
 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"
+```
 
-# Backup
+### Step 2: 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"
+```
+
+### Step 2b: Confirm (skip if `--force`)
+
+If `--force` flag is NOT set:
 
-# Reset snapshot to parent branch (develop or main depending on context)
+```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"
 
-# ═══════════════════════════════════════════════════════════════════════════
-# MANDATORY: SQL Objects Post-Injection
-# Without this, TVFs (fn_GetUserGroupHierarchy etc.) won't exist in DB
-# and ALL endpoints will return 500 at runtime
-# ═══════════════════════════════════════════════════════════════════════════
-MIGRATION_FILE=$(find Migrations -name "*${MIGRATION_NAME}.cs" ! -name "*.Designer.cs" | head -1)
-SQL_OBJECTS_DIR="$INFRA_PROJECT_DIR/Persistence/SqlObjects"
-SQL_FILES=$(find "$SQL_OBJECTS_DIR" -name "*.sql" 2>/dev/null | wc -l)
+dotnet ef migrations add "$MCP_MIGRATION_NAME" \
+  --context "$DBCONTEXT" \
+  --project "$INFRA_PROJECT" \
+  --startup-project "$STARTUP_PROJECT" \
+  -o Persistence/Migrations
 
-if [ "$SQL_FILES" -gt 0 ]; then
-  echo "Found $SQL_FILES SQL object(s) — injecting SqlObjectHelper.ApplyAll()..."
-
-  # Add using directive if not present
-  if ! grep -q "using SmartStack.Infrastructure.Persistence.SqlObjects;" "$MIGRATION_FILE"; then
-    sed -i '1s/^/using SmartStack.Infrastructure.Persistence.SqlObjects;\n/' "$MIGRATION_FILE"
-  fi
-
-  # Inject SqlObjectHelper.ApplyAll before Down() method
-  sed -i '/protected override void Down/i\
-\            // Apply SQL objects (TVF, Views, SP) from embedded resources\
-\            SqlObjectHelper.ApplyAll(migrationBuilder);' "$MIGRATION_FILE"
-
-  # VERIFY — FAIL if injection didn't work
-  if ! grep -q "SqlObjectHelper.ApplyAll" "$MIGRATION_FILE"; then
-    echo "ERROR: Auto-injection failed. Use Edit tool to manually add:"
-    echo "  1. 'using SmartStack.Infrastructure.Persistence.SqlObjects;' at top"
-    echo "  2. 'SqlObjectHelper.ApplyAll(migrationBuilder);' at end of Up()"
-    echo "  File: $MIGRATION_FILE"
-  else
-    echo "  SqlObjectHelper.ApplyAll(migrationBuilder) injected"
-    find "$SQL_OBJECTS_DIR" -name "*.sql" -exec basename {} \; | while read f; do echo "  - $f"; done
-  fi
-else
-  echo "No SQL objects found — skipping injection"
-fi
+# NOTE: SQL objects are applied automatically at startup — no injection needed.
 
 # Validate
 dotnet build
@@ -130,7 +180,6 @@ core_v1.7.0_001_ReleaseInitial
 - [ ] Backup created
 - [ ] Build OK after rebase
 - [ ] SQL script can be generated
-- [ ] SQL objects injected (if `Persistence/SqlObjects/*.sql` exists)
 
 ## Error Recovery
 
@@ -140,7 +189,7 @@ core_v1.7.0_001_ReleaseInitial
 | MCP unavailable | Check `.claude/mcp-status.json`, run `/mcp healthcheck` |
 | Snapshot fetch fails | Verify `origin/$BASE_BRANCH` exists: `git fetch origin $BASE_BRANCH` |
 | Migration creation fails | Restore backup, check `dotnet build` output |
-| SQL objects injection fails | Manual step: add `SqlObjectHelper.ApplyAll(migrationBuilder)` in Up() |
+| SQL objects missing at runtime | SQL objects are applied at startup — restart the application |
 
 **Automatic recovery:** On ANY failure after backup:
 1. Restore all files from backup directory

package/templates/agents/efcore/squash.md

@@ -3,7 +3,7 @@ name: efcore-squash
 description: EF Core migration squasher - combine multiple migrations into one
 color: magenta
 model: sonnet
-tools: Bash, Glob, Read
+tools: Bash, Glob, Read, Edit
 ---
 
 # EF Core Squash Agent
@@ -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.
-Migrations reference these via `SqlObjectHelper.ApplyAll(migrationBuilder)` — never inline SQL.
+SQL objects (TVFs, views, SPs) are applied **at startup** via `SqlObjectHelper.ApplyAllAsync()` — never inject in migrations.
 
 ## Core Principle
 
@@ -51,93 +48,160 @@ WARNING: NEVER retrieve only the snapshot without the migrations!
 5. **Fetch**: Retrieve **ModelSnapshot AND migrations** from parent branch (CRUCIAL!)
 6. **Delete**: Remove branch-specific migrations ONLY
 7. **Create**: Create consolidated migration (MCP mandatory)
-8. **Inject SQL Objects**: If `Persistence/SqlObjects/` contains `.sql` files, inject `SqlObjectHelper.ApplyAll(migrationBuilder)` in `Up()`
-9. **Validate**: Build + script OK
+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
+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:-}"
+```
+
+### 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
-# Determine parent branch and DbContext
-determine_base_branch   # → BASE_BRANCH, BRANCH_TYPE
-detect_efcore_project   # → $DBCONTEXT, $DBCONTEXT_TYPE, $SCHEMA
+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" }
+  ]
+})
+```
 
-# 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 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"
-
-# ═══════════════════════════════════════════════════════════════════════════
-# MANDATORY: SQL Objects Post-Injection
-# Without this, TVFs (fn_GetUserGroupHierarchy etc.) won't exist in DB
-# and ALL endpoints will return 500 at runtime
-# ═══════════════════════════════════════════════════════════════════════════
-MIGRATION_FILE=$(find Migrations -name "*${MIGRATION_NAME_FROM_MCP}.cs" ! -name "*.Designer.cs" | head -1)
-SQL_OBJECTS_DIR="$INFRA_PROJECT_DIR/Persistence/SqlObjects"
-SQL_FILES=$(find "$SQL_OBJECTS_DIR" -name "*.sql" 2>/dev/null | wc -l)
+# 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
 
-if [ "$SQL_FILES" -gt 0 ]; then
-  echo "Found $SQL_FILES SQL object(s) — injecting SqlObjectHelper.ApplyAll()..."
-
-  # Add using directive if not present
-  if ! grep -q "using SmartStack.Infrastructure.Persistence.SqlObjects;" "$MIGRATION_FILE"; then
-    sed -i '1s/^/using SmartStack.Infrastructure.Persistence.SqlObjects;\n/' "$MIGRATION_FILE"
-  fi
-
-  # Inject SqlObjectHelper.ApplyAll before Down() method
-  sed -i '/protected override void Down/i\
-\            // Apply SQL objects (TVF, Views, SP) from embedded resources\
-\            SqlObjectHelper.ApplyAll(migrationBuilder);' "$MIGRATION_FILE"
-
-  # VERIFY — FAIL if injection didn't work
-  if ! grep -q "SqlObjectHelper.ApplyAll" "$MIGRATION_FILE"; then
-    echo "ERROR: Auto-injection failed. Use Edit tool to manually add:"
-    echo "  1. 'using SmartStack.Infrastructure.Persistence.SqlObjects;' at top"
-    echo "  2. 'SqlObjectHelper.ApplyAll(migrationBuilder);' at end of Up()"
-    echo "  File: $MIGRATION_FILE"
-  else
-    echo "  SqlObjectHelper.ApplyAll(migrationBuilder) injected"
-    find "$SQL_OBJECTS_DIR" -name "*.sql" -exec basename {} \; | while read f; do echo "  - $f"; done
-  fi
-else
-  echo "No SQL objects found — skipping injection"
-fi
+# 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
@@ -149,7 +213,6 @@ dotnet build && dotnet ef migrations script --idempotent > /dev/null
 - [ ] **Parent snapshot retrieved** (origin/$BASE_BRANCH)
 - [ ] **Parent migrations retrieved** (.cs AND .Designer.cs files)
 - [ ] Branch-specific migrations deleted (not inherited ones!)
-- [ ] **SQL Objects injected** (if `Persistence/SqlObjects/*.sql` exists)
 - [ ] Build OK after squash
 - [ ] Script can be generated
 
@@ -165,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}/
 
@@ -189,7 +252,7 @@ Next: /efcore db-reset, /efcore db-deploy
 | MCP unavailable | Check `.claude/mcp-status.json`, run `/mcp healthcheck` |
 | Snapshot fetch fails | Verify `origin/$BASE_BRANCH` exists: `git fetch origin $BASE_BRANCH` |
 | Script generation fails | Restore backup, then investigate migration content |
-| SQL objects injection fails | Manual step: add `SqlObjectHelper.ApplyAll(migrationBuilder)` in Up() |
+| SQL objects missing at runtime | SQL objects are applied at startup — restart the application |
 
 **Automatic recovery:** On ANY failure after backup:
 1. Restore all files from backup directory

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