@atlashub/smartstack-cli 3.37.0 → 3.39.0

package/templates/skills/gitflow/references/commit-message-generation.md

@@ -0,0 +1,58 @@
+# Commit Message Generation
+
+## Determine Commit Type
+
+```bash
+# Determine commit type from branch
+BRANCH_TYPE=$(echo $CURRENT | cut -d'/' -f1)
+case "$BRANCH_TYPE" in
+  feature) PREFIX="feat" ;;
+  hotfix)  PREFIX="fix" ;;
+  release) PREFIX="chore" ;;
+  *)       PREFIX="chore" ;;
+esac
+
+# Determine scope from branch name
+SCOPE=$(echo $CURRENT | cut -d'/' -f2 | cut -d'-' -f1)
+
+# If migrations present
+[ "$HAS_MIGRATIONS" = "true" ] && PREFIX="db(migrations)"
+
+# Generate message from diff analysis
+SUMMARY=$(git diff --cached --stat | tail -1 | sed 's/^ *//')
+```
+
+## Message Format
+
+```
+{type}({scope}): {summary - 50 chars max}
+
+**CHANGE**
+PROBLEM: {what was wrong}
+SOLUTION: {what was done}
+IMPACT: {benefit}
+
+Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
+```
+
+## Stage and Create Commit
+
+```bash
+# Stage all changes
+git add -A
+
+# Show what will be committed
+echo "Files to commit:"
+git diff --cached --stat
+```
+
+## Create Commit
+
+```bash
+git commit -m "$(cat <<'EOF'
+{generated_message}
+EOF
+)"
+
+COMMIT_HASH=$(git rev-parse --short HEAD)
+```

package/templates/skills/gitflow/references/commit-migration-validation.md

@@ -0,0 +1,49 @@
+# Migration File Validation
+
+## Detect EF Core Migrations
+
+```bash
+# Find migration files in changes
+MIGRATIONS=$(echo "$STAGED $MODIFIED $UNTRACKED" | tr ' ' '\n' | grep -E "Migrations/.*\.cs$")
+HAS_MIGRATIONS=$([ -n "$MIGRATIONS" ] && echo "true" || echo "false")
+
+if [ "$HAS_MIGRATIONS" = "true" ]; then
+  # Check for the 3 required files
+  MIGRATION_NAME=$(echo "$MIGRATIONS" | grep -v "Designer\|Snapshot" | head -1 | sed 's/.*\///' | sed 's/\.cs$//')
+
+  HAS_MAIN=$(echo "$MIGRATIONS" | grep -c "${MIGRATION_NAME}.cs")
+  HAS_DESIGNER=$(echo "$MIGRATIONS" | grep -c "${MIGRATION_NAME}.Designer.cs")
+  HAS_SNAPSHOT=$(echo "$MIGRATIONS" | grep -c "ModelSnapshot.cs")
+
+  [ "$HAS_MAIN" -eq 0 ] || [ "$HAS_DESIGNER" -eq 0 ] || [ "$HAS_SNAPSHOT" -eq 0 ] && {
+    echo "❌ INCOMPLETE MIGRATION"
+    echo "Required: Migration.cs + Designer.cs + ModelSnapshot.cs"
+    echo "Found: Main=$HAS_MAIN, Designer=$HAS_DESIGNER, Snapshot=$HAS_SNAPSHOT"
+    STOP
+  }
+fi
+```
+
+## Check Destructive Operations (BLOCKING)
+
+```bash
+if [ "$HAS_MIGRATIONS" = "true" ]; then
+  DESTRUCTIVE=$(grep -l "DropTable\|DropColumn\|DeleteData" $MIGRATIONS 2>/dev/null)
+
+  [ -n "$DESTRUCTIVE" ] && {
+    echo "⚠️ DESTRUCTIVE OPERATIONS DETECTED"
+    grep -n "DropTable\|DropColumn\|DeleteData" $DESTRUCTIVE
+
+    # Require explicit confirmation
+    AskUserQuestion:
+      header: "Confirm"
+      question: "Destructive migration detected. Continue?"
+      options:
+        - label: "Yes, I understand the risks"
+        - label: "No, let me review"
+
+    # Log to audit trail
+    echo "$(date) - DESTRUCTIVE: $DESTRUCTIVE - User: $USER" >> .claude/gitflow/logs/audit.log
+  }
+fi
+```

package/templates/skills/gitflow/references/finish-cleanup.md

@@ -0,0 +1,55 @@
+# Worktree and Branch Cleanup
+
+## Clean Up Worktree
+
+```bash
+# Repair cross-platform worktree paths before cleanup (WSL ↔ Windows)
+detect_platform
+repair_worktree_paths "$(git rev-parse --git-common-dir 2>/dev/null || echo '.bare')"
+
+# Find worktree for this branch (use --porcelain for reliable parsing)
+WORKTREE_PATH=$(git worktree list --porcelain | grep -B2 "branch refs/heads/$BRANCH" | grep "^worktree " | sed 's/^worktree //')
+
+if [ -n "$WORKTREE_PATH" ] && [ -d "$WORKTREE_PATH" ]; then
+  echo "Removing worktree: $WORKTREE_PATH"
+
+  # Make sure we're not in the worktree directory
+  cd "$GF_DEVELOP_PATH" 2>/dev/null || cd "$(git rev-parse --show-toplevel)"
+
+  git worktree remove "$WORKTREE_PATH" --force 2>/dev/null || {
+    rm -rf "$WORKTREE_PATH"
+  }
+
+  git worktree prune
+  echo "✅ Worktree removed"
+fi
+```
+
+## Delete Remote and Local Branches
+
+```bash
+# Check if remote branch still exists
+REMOTE_EXISTS=$(git branch -r --list "origin/$BRANCH")
+
+if [ -n "$REMOTE_EXISTS" ]; then
+  echo "Deleting remote branch: $BRANCH"
+  git push origin --delete "$BRANCH" 2>/dev/null || {
+    echo "⚠️ Could not delete remote branch (may already be deleted by PR)"
+  }
+fi
+
+# Delete local branch
+git branch -D "$BRANCH" 2>/dev/null || echo "Local branch already deleted"
+```
+
+## Archive Plan
+
+```bash
+PLAN_FILE=$(ls .claude/gitflow/plans/*${BRANCH_NAME}*.md 2>/dev/null | head -1)
+
+if [ -f "$PLAN_FILE" ]; then
+  ARCHIVE_NAME="${PLAN_FILE%.md}_DONE_$(date +%Y%m%d-%H%M%S).md"
+  mv "$PLAN_FILE" "$ARCHIVE_NAME"
+  echo "✅ Plan archived: $ARCHIVE_NAME"
+fi
+```

package/templates/skills/gitflow/references/finish-version-bumping.md

@@ -0,0 +1,45 @@
+# Version Bumping After Release/Hotfix
+
+## Determine Next Version
+
+```bash
+MAJOR=$(echo $VERSION | cut -d'.' -f1)
+MINOR=$(echo $VERSION | cut -d'.' -f2)
+PATCH=$(echo $VERSION | cut -d'.' -f3)
+
+if [ "$BRANCH_TYPE" = "release" ]; then
+  # Release: increment minor, reset patch
+  NEXT_VERSION="$MAJOR.$((MINOR + 1)).0"
+else
+  # Hotfix: increment patch (patch was already bumped for the tag, bump again for next dev)
+  NEXT_VERSION="$MAJOR.$MINOR.$((PATCH + 2))"
+fi
+```
+
+## Update Configuration and Source Files
+
+```bash
+# Update config (using resolved config path)
+sed -i "s/\"current\": \".*\"/\"current\": \"$NEXT_VERSION\"/" "$GF_CONFIG_FILE"
+
+# Update source files
+# csproj, package.json, etc.
+
+git add -A
+git commit -m "chore: bump version to $NEXT_VERSION for development"
+git push origin $GF_DEVELOP_BRANCH
+
+# CRITICAL: Verify push and update tracking refs
+git fetch origin $GF_DEVELOP_BRANCH:refs/remotes/origin/$GF_DEVELOP_BRANCH --force --quiet
+LOCAL_SHA=$(git rev-parse HEAD)
+REMOTE_SHA=$(git rev-parse origin/$GF_DEVELOP_BRANCH)
+if [ "$LOCAL_SHA" = "$REMOTE_SHA" ]; then
+  echo "✅ Push verified - local/remote in sync"
+else
+  echo "⚠️ Push verification FAILED"
+  echo "  Local:  $LOCAL_SHA"
+  echo "  Remote: $REMOTE_SHA"
+fi
+
+echo "✅ Version bumped to $NEXT_VERSION"
+```

package/templates/skills/gitflow/references/init-environment-detection.md

@@ -0,0 +1,41 @@
+# Environment Detection
+
+## Platform and Git Detection
+
+```bash
+# PLATFORM DETECTION (required for correct path handling on WSL/Windows/macOS/Linux)
+if [ -f /proc/version ] && grep -qi "microsoft\|wsl" /proc/version 2>/dev/null; then
+  GF_PLATFORM="wsl"; GF_SHELL="bash"
+elif [[ "$OSTYPE" == "msys" ]] || [[ "$OSTYPE" == "mingw"* ]] || [[ "$OSTYPE" == "cygwin" ]]; then
+  GF_PLATFORM="windows"; GF_SHELL="gitbash"
+elif [[ -n "$WINDIR" ]] || [[ -n "$SystemRoot" ]]; then
+  GF_PLATFORM="windows"; GF_SHELL="powershell"
+elif [[ "$OSTYPE" == "darwin"* ]]; then
+  GF_PLATFORM="macos"; GF_SHELL="zsh"
+elif [[ "$OSTYPE" == "linux-gnu"* ]]; then
+  GF_PLATFORM="linux"; GF_SHELL="bash"
+else
+  GF_PLATFORM="unknown"; GF_SHELL="bash"
+fi
+echo "Platform: $GF_PLATFORM ($GF_SHELL)"
+
+# Check if we're in a git repository
+IS_GIT_REPO=$(git rev-parse --git-dir 2>/dev/null && echo "true" || echo "false")
+
+# Auto-detect values for defaults (will be confirmed by user)
+DETECTED_URL=$(git remote get-url origin 2>/dev/null || echo "")
+DETECTED_FOLDER=$(dirname "$(pwd)")
+DETECTED_NAME=$(basename -s .git "$DETECTED_URL" 2>/dev/null || basename "$(pwd)")
+
+# Detect git provider
+if [[ "$DETECTED_URL" == *"github.com"* ]]; then
+  GIT_PROVIDER="github"
+elif [[ "$DETECTED_URL" == *"dev.azure.com"* ]]; then
+  GIT_PROVIDER="azuredevops"
+else
+  GIT_PROVIDER="unknown"
+fi
+
+# Check if already initialized
+ALREADY_INITIALIZED=$([ -f ".claude/gitflow/config.json" ] && echo "true" || echo "false")
+```

package/templates/skills/gitflow/references/init-questions.md

@@ -0,0 +1,185 @@
+# MANDATORY User Questions for Init
+
+All questions must be asked in order. See step-init.md for context on when each is asked.
+
+## Question 1: Repository URL
+
+**⛔ ALWAYS ask, even if URL was detected:**
+
+```yaml
+AskUserQuestion:
+  - header: "Repository"
+    question: "Repository URL? (detected: {DETECTED_URL})"
+    options:
+      - label: "Use detected URL (Recommended)"
+        description: "{DETECTED_URL}"
+      - label: "Enter GitHub URL"
+        description: "https://github.com/org/repo.git"
+      - label: "Enter Azure DevOps URL"
+        description: "https://dev.azure.com/org/project/_git/repo"
+      - label: "Local only (no remote)"
+        description: "Initialize without remote (limited features)"
+    multiSelect: false
+```
+
+**⛔ FOLLOW-UP: If user selects "Enter GitHub URL" or "Enter Azure DevOps URL":**
+
+The selected option is just a choice, NOT the actual URL. You MUST ask a follow-up question:
+
+```yaml
+AskUserQuestion:
+  - header: "URL"
+    question: "Enter the repository URL:"
+    options:
+      - label: "https://github.com/org/repo.git"
+        description: "Example GitHub format"
+      - label: "https://dev.azure.com/org/project/_git/repo"
+        description: "Example Azure DevOps format"
+    multiSelect: false
+```
+
+The user will type the actual URL via "Other". Then:
+- Validate format
+- Update `{REPO_URL}` and `{GIT_PROVIDER}`
+
+## Question 2: Root Folder
+
+**⛔ ALWAYS ask where to create THIS project's structure:**
+
+**If sibling projects exist, show where it fits:**
+
+```
+{WORKSPACE_DIR}/
+├── SmartStack.app/    ✅ (gitflow)
+├── SmartStack.mcp/    ✅ (gitflow)
+├── SmartStack.cli/    ✅ (gitflow)
+└── NewProject/        ← THIS PROJECT
+    ├── .bare/
+    ├── 01-Main/
+    ├── 02-Develop/
+    ├── features/
+    ├── releases/
+    └── hotfixes/
+```
+
+```yaml
+AskUserQuestion:
+  - header: "Location"
+    question: "Root folder for THIS project? (worktrees will be created here)"
+    options:
+      - label: "Use parent folder (Recommended)"
+        description: "{DETECTED_FOLDER}/ - consistent with {#SIBLING_PROJECTS} sibling project(s)"
+      - label: "Use current folder"
+        description: "$(pwd)/ - Will create subfolders here"
+      - label: "Custom path"
+        description: "Specify a different location"
+    multiSelect: false
+```
+
+**⛔ FOLLOW-UP: If user selects "Custom path":**
+
+You MUST ask a follow-up question to get the actual path:
+
+```yaml
+AskUserQuestion:
+  - header: "Path"
+    question: "Enter the full path for the project root folder:"
+    options:
+      - label: "{DETECTED_FOLDER}/"
+        description: "Parent of current directory"
+      - label: "{WORKSPACE_DIR}/"
+        description: "Workspace root"
+    multiSelect: false
+```
+
+The user will type the actual path via "Other". Validate the path exists or can be created.
+
+**Explain the structure that will be created for this project:**
+
+```
+{ROOT_FOLDER}/
+├── .bare/                 # Git bare repository (this repo only)
+├── 01-Main/               # Worktree: main branch
+├── 02-Develop/            # Worktree: develop branch
+├── features/              # Feature branch worktrees
+├── releases/              # Release branch worktrees
+└── hotfixes/              # Hotfix branch worktrees
+```
+
+## Question 3: Project Name
+
+**⛔ ALWAYS ask to confirm project name:**
+
+```yaml
+AskUserQuestion:
+  - header: "Project"
+    question: "Project name? (detected: {DETECTED_NAME})"
+    options:
+      - label: "Use detected name (Recommended)"
+        description: "Project: {DETECTED_NAME}"
+      - label: "Custom name"
+        description: "Specify a different project name"
+    multiSelect: false
+```
+
+**⛔ FOLLOW-UP: If user selects "Custom name":**
+
+You MUST ask a follow-up question to get the actual name:
+
+```yaml
+AskUserQuestion:
+  - header: "Name"
+    question: "Enter the project name:"
+    options:
+      - label: "{DETECTED_NAME}"
+        description: "Detected from repository"
+      - label: "{DETECTED_NAME}-v2"
+        description: "Variant of detected name"
+    multiSelect: false
+```
+
+The user will type the actual name via "Other". Use this raw input for step 6b (normalization).
+
+## Question 4: Existing Configuration
+
+**If `ALREADY_INITIALIZED` = true:**
+
+Display current configuration and ask what to do:
+
+```yaml
+AskUserQuestion:
+  - header: "Existing"
+    question: "GitFlow is already initialized. Current config will be shown. What do you want to do?"
+    options:
+      - label: "Reconfigure (Recommended)"
+        description: "Review and update all settings"
+      - label: "Repair"
+        description: "Fix missing directories only"
+      - label: "View only"
+        description: "Display current config and exit"
+      - label: "Cancel"
+        description: "Exit without changes"
+    multiSelect: false
+```
+
+**Handle choices:**
+- **Reconfigure**: Continue to step 4 (will ask all questions again)
+- **Repair**: Check directories, fix missing ones, exit
+- **View only**: Display config, exit
+- **Cancel**: Exit immediately
+
+## Question 5: Worktree Mode
+
+```yaml
+AskUserQuestion:
+  - header: "Worktrees"
+    question: "How should worktrees be organized?"
+    options:
+      - label: "Organized (Recommended)"
+        description: "01-Main, 02-Develop, features/, releases/, hotfixes/"
+      - label: "Simple"
+        description: "main/, develop/, features/, releases/, hotfixes/"
+      - label: "Disabled"
+        description: "No worktrees, use git checkout (not recommended)"
+    multiSelect: false
+```

package/templates/skills/gitflow/references/init-structure-creation.md

@@ -0,0 +1,75 @@
+# Directory Structure Creation
+
+## Path Normalization for WSL
+
+```bash
+# If on WSL, translate Windows paths to /mnt/ format
+# normalize_path_for_platform() from _shared.md handles this
+# Example: D:/projects/MyApp → /mnt/d/projects/MyApp
+PROJECT_BASE="{ROOT_FOLDER}"  # Must be already normalized for current platform
+```
+
+## Create Complete Structure
+
+**⛔ CRITICAL: Use ABSOLUTE PATHS for ALL operations. NEVER use `cd` (it does not persist between Bash calls).**
+**⛔ Use `git -C <path>` or `GIT_DIR=<path>` instead of `cd` + `git`.**
+
+```bash
+PROJECT_BASE="{ROOT_FOLDER}"
+
+# Create subdirectories (absolute paths)
+mkdir -p "$PROJECT_BASE/features" "$PROJECT_BASE/releases" "$PROJECT_BASE/hotfixes"
+
+# Create bare repository if not exists (absolute path, no cd)
+if [ ! -d "$PROJECT_BASE/.bare" ]; then
+  git clone --bare "{REPO_URL}" "$PROJECT_BASE/.bare"
+
+  # Configure bare repo for worktrees (using git -C, no cd)
+  git -C "$PROJECT_BASE/.bare" config core.bare false
+  git -C "$PROJECT_BASE/.bare" config core.worktree ..
+fi
+
+# Create .git pseudo-file pointing to .bare
+echo "gitdir: ./.bare" > "$PROJECT_BASE/.git"
+
+# Organized mode: numbered main folders (absolute paths, GIT_DIR instead of cd)
+if [ "$WORKTREE_MODE" = "organized" ]; then
+  [ ! -d "$PROJECT_BASE/01-Main" ] && \
+    GIT_DIR="$PROJECT_BASE/.bare" git worktree add "$PROJECT_BASE/01-Main" main
+
+  [ ! -d "$PROJECT_BASE/02-Develop" ] && \
+    GIT_DIR="$PROJECT_BASE/.bare" git worktree add "$PROJECT_BASE/02-Develop" develop
+fi
+
+# Simple mode: named folders (absolute paths)
+if [ "$WORKTREE_MODE" = "simple" ]; then
+  [ ! -d "$PROJECT_BASE/main" ] && \
+    GIT_DIR="$PROJECT_BASE/.bare" git worktree add "$PROJECT_BASE/main" main
+
+  [ ! -d "$PROJECT_BASE/develop" ] && \
+    GIT_DIR="$PROJECT_BASE/.bare" git worktree add "$PROJECT_BASE/develop" develop
+fi
+
+# Convert worktree paths to relative format (cross-platform: Windows + WSL)
+detect_platform
+repair_worktree_paths "$PROJECT_BASE/.bare"
+
+# Create gitflow config directory (absolute paths)
+DEVELOP_DIR=$([ "$WORKTREE_MODE" = "organized" ] && echo "02-Develop" || echo "develop")
+mkdir -p "$PROJECT_BASE/$DEVELOP_DIR/.claude/gitflow/plans"
+mkdir -p "$PROJECT_BASE/$DEVELOP_DIR/.claude/gitflow/logs"
+mkdir -p "$PROJECT_BASE/$DEVELOP_DIR/.claude/gitflow/cache"
+mkdir -p "$PROJECT_BASE/$DEVELOP_DIR/.claude/gitflow/backup"
+```
+
+## Folder Structure to Create
+
+```
+{ROOT_FOLDER}/
+├── .bare/                 # Git bare repository (this repo only)
+├── 01-Main/               # Worktree: main branch
+├── 02-Develop/            # Worktree: develop branch
+├── features/              # Feature branch worktrees
+├── releases/              # Release branch worktrees
+└── hotfixes/              # Hotfix branch worktrees
+```

package/templates/skills/gitflow/references/init-version-detection.md

@@ -0,0 +1,21 @@
+# Version Detection
+
+## Detect Version (with Priority)
+
+**⛔ Use absolute paths with `git -C`, no `cd`.**
+
+```bash
+DEVELOP_FULL_PATH="$PROJECT_BASE/$DEVELOP_DIR"
+
+# Priority: csproj > Directory.Build.props > package.json > VERSION > tag
+VERSION=$(grep -oP '<Version>\K[^<]+' "$DEVELOP_FULL_PATH"/*.csproj 2>/dev/null | head -1)
+[ -z "$VERSION" ] && VERSION=$(grep -oP '<Version>\K[^<]+' "$DEVELOP_FULL_PATH/Directory.Build.props" 2>/dev/null)
+[ -z "$VERSION" ] && VERSION=$(grep -oP '"version":\s*"\K[^"]+' "$DEVELOP_FULL_PATH/package.json" 2>/dev/null)
+[ -z "$VERSION" ] && VERSION=$(cat "$DEVELOP_FULL_PATH/VERSION" 2>/dev/null)
+[ -z "$VERSION" ] && VERSION=$(git -C "$DEVELOP_FULL_PATH" describe --tags --abbrev=0 2>/dev/null | sed 's/^v//')
+[ -z "$VERSION" ] && VERSION="0.1.0"
+```
+
+## Version will be stored in config.json
+
+The detected version is used in the GitFlow config template under `versioning.current`.

package/templates/skills/gitflow/references/init-workspace-detection.md

@@ -0,0 +1,43 @@
+# Workspace Detection
+
+## Scan for Sibling Projects
+
+```bash
+WORKSPACE_DIR=$(dirname "$(pwd)")
+SIBLING_PROJECTS=()
+
+for dir in "$WORKSPACE_DIR"/*/; do
+  [ -d "$dir/.bare" ] || [ -d "$dir/01-Main" ] || [ -d "$dir/02-Develop" ] && {
+    PROJECT_NAME_SIBLING=$(basename "$dir")
+    SIBLING_PROJECTS+=("$PROJECT_NAME_SIBLING")
+  }
+done
+```
+
+## Display Workspace Context
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│  WORKSPACE: {WORKSPACE_DIR}                                  │
+├─────────────────────────────────────────────────────────────┤
+│  Each project has its OWN independent GitFlow configuration. │
+│  This init configures only: {DETECTED_NAME}                  │
+├─────────────────────────────────────────────────────────────┤
+{if SIBLING_PROJECTS not empty}
+│  Existing GitFlow projects:                                  │
+│  {for each SIBLING} ✅ {SIBLING_NAME}/                       │
+│     ├── .bare/  01-Main/  02-Develop/                        │
+│     └── features/  releases/  hotfixes/                      │
+│  {end for}                                                   │
+│                                                              │
+│  New project to initialize:                                  │
+│  ⬜ {DETECTED_NAME}/                                         │
+│     └── (same structure will be created)                     │
+{else}
+│  No existing GitFlow projects detected.                      │
+│  This will be the first project in this workspace.           │
+{endif}
+└─────────────────────────────────────────────────────────────┘
+```
+
+**Key principle:** GitFlow is **per-repository**. Each project has its own `config.json`, its own worktree structure, and its own version history. Projects do not share configuration.

package/templates/skills/gitflow/references/merge-ci-status.md

@@ -0,0 +1,36 @@
+# Check CI and Review Status
+
+## Check CI Status (GitHub)
+
+```bash
+if [ "$GIT_PROVIDER" = "github" ]; then
+  CI_STATUS=$(gh pr checks $PR_NUMBER --json state --jq '.[].state' | sort -u)
+
+  [[ "$CI_STATUS" == *"FAILURE"* ]] && {
+    echo "❌ CI checks failing"
+    gh pr checks $PR_NUMBER
+
+    if [ "$auto_mode" != true ]; then
+      AskUserQuestion:
+        header: "CI"
+        question: "CI checks are failing. Continue anyway?"
+        options:
+          - label: "Wait for fix"
+          - label: "Merge anyway (not recommended)"
+    fi
+  }
+fi
+```
+
+## Check Review Status (GitHub)
+
+```bash
+if [ "$GIT_PROVIDER" = "github" ]; then
+  REVIEWS=$(gh pr view $PR_NUMBER --json reviews --jq '.reviews | map(select(.state == "APPROVED")) | length')
+  REQUIRED_REVIEWS=$(gh api repos/:owner/:repo --jq '.default_branch_protection.required_pull_request_reviews.required_approving_review_count // 0')
+
+  [ "$REVIEWS" -lt "$REQUIRED_REVIEWS" ] && {
+    echo "⚠️ Needs $REQUIRED_REVIEWS approvals, has $REVIEWS"
+  }
+fi
+```

package/templates/skills/gitflow/references/merge-execution.md

@@ -0,0 +1,62 @@
+# Merge Execution and Verification
+
+## Determine Merge Strategy
+
+```bash
+BRANCH_TYPE=$(echo $CURRENT | cut -d'/' -f1)
+
+case "$BRANCH_TYPE" in
+  feature)
+    MERGE_STRATEGY="squash"
+    DELETE_BRANCH=true
+    ;;
+  release|hotfix)
+    MERGE_STRATEGY="merge"
+    DELETE_BRANCH=true
+    MERGE_BACK="$GF_DEVELOP_BRANCH"
+    ;;
+esac
+```
+
+## Execute Merge
+
+**GitHub:**
+```bash
+case "$MERGE_STRATEGY" in
+  squash)
+    gh pr merge $PR_NUMBER --squash --delete-branch
+    ;;
+  merge)
+    gh pr merge $PR_NUMBER --merge --delete-branch
+    ;;
+esac
+```
+
+**Azure DevOps:**
+```bash
+case "$MERGE_STRATEGY" in
+  squash)
+    az repos pr update --id $PR_NUMBER --status completed --squash true --delete-source-branch true
+    ;;
+  merge)
+    az repos pr update --id $PR_NUMBER --status completed --squash false --delete-source-branch true
+    ;;
+esac
+```
+
+## Verify Merge
+
+```bash
+# CRITICAL: Force update tracking refs to get accurate state
+git fetch origin $TARGET_BRANCH:refs/remotes/origin/$TARGET_BRANCH --force --quiet
+git fetch origin --prune --quiet
+
+MERGED=$(git branch -r --merged origin/$TARGET_BRANCH | grep "$CURRENT" | wc -l)
+
+[ "$MERGED" -eq 0 ] && {
+  echo "⚠️ Merge verification failed - branch may not be merged"
+  echo "  → Check PR status on remote"
+} || {
+  echo "✅ Merge verified - branch merged to $TARGET_BRANCH"
+}
+```