@atlashub/smartstack-cli 3.36.0 → 3.38.0

package/templates/skills/efcore/steps/shared/step-00-init.md

@@ -16,145 +16,18 @@ Detect EF Core project structure, identify DbContext (Core vs Extensions), and l
 
 ## EXECUTION SEQUENCE:
 
-### 0. Ensure dotnet ef Available (Platform-Aware)
+Load all helper functions from: `references/shared-init-functions.md`
 
-> **CRITICAL:** On Windows (Git Bash, MSYS2), `dotnet ef` may not be on the shell PATH
-> even though it's installed. This step fixes PATH before any EF Core command.
+This includes:
+- `ensure_dotnet_ef()` - Platform-aware dotnet-ef PATH fix
+- `detect_efcore_project()` - Find EF Core project
+- `detect_dbcontext()` - Detect Core vs Extensions
+- `detect_environment()` - Load environment configuration
+- `determine_base_branch()` - Determine GitFlow branch
+- `block_production()` - Prevent production deployments
+- `run_for_contexts()` - Helper for dual context execution
 
-```bash
-ensure_dotnet_ef() {
-  # Quick check: already available?
-  if dotnet ef --version &>/dev/null; then
-    DOTNET_EF_VERSION=$(dotnet ef --version 2>/dev/null)
-    echo "dotnet-ef: $DOTNET_EF_VERSION"
-    return 0
-  fi
-
-  echo "dotnet-ef not on PATH, attempting platform-aware fix..."
-
-  # Try all known .NET global tools locations
-  # - $USERPROFILE/.dotnet/tools  → Windows via Git Bash (USERPROFILE=C:\Users\xxx)
-  # - $HOME/.dotnet/tools         → Linux/macOS or Git Bash fallback
-  # - $LOCALAPPDATA/Microsoft/dotnet/tools → Windows alternate location
-  for TOOLS_DIR in \
-    "$USERPROFILE/.dotnet/tools" \
-    "$HOME/.dotnet/tools" \
-    "$LOCALAPPDATA/Microsoft/dotnet/tools"; do
-    if [ -n "$TOOLS_DIR" ] && [ -d "$TOOLS_DIR" ]; then
-      export PATH="$TOOLS_DIR:$PATH"
-      echo "  PATH += $TOOLS_DIR"
-    fi
-  done
-
-  # Verify after PATH fix
-  if dotnet ef --version &>/dev/null; then
-    DOTNET_EF_VERSION=$(dotnet ef --version 2>/dev/null)
-    echo "dotnet-ef: $DOTNET_EF_VERSION (found after PATH fix)"
-    return 0
-  fi
-
-  echo "ERROR: dotnet-ef not available"
-  echo "Install with: dotnet tool install --global dotnet-ef"
-  echo ""
-  echo "If installed but not found, check:"
-  echo "  Windows: %USERPROFILE%\\.dotnet\\tools must be in PATH"
-  echo "  Linux:   ~/.dotnet/tools must be in PATH"
-  exit 1
-}
-
-ensure_dotnet_ef
-```
-
-**IMPORTANT — WSL pitfall:**
-If the shell resolves `$HOME` to `/home/{user}` (WSL path) instead of `/c/Users/{user}` (Git Bash),
-the .NET SDK may not be found even if `dotnet-ef` is. Use `$USERPROFILE` first on Windows.
-
----
-
-### 1. Detect EF Core Project
-
-```bash
-detect_efcore_project() {
-  # Find project with EF Core reference
-  CSPROJ=$(find . -name "*.csproj" -exec grep -l "Microsoft.EntityFrameworkCore" {} \; | head -1)
-
-  if [ -z "$CSPROJ" ]; then
-    echo "ERROR: No EF Core project found"
-    exit 1
-  fi
-
-  PROJECT_DIR=$(dirname "$CSPROJ")
-  PROJECT_NAME=$(basename "$CSPROJ" .csproj)
-  MIGRATIONS_DIR="$PROJECT_DIR/Persistence/Migrations"
-
-  # Find startup and infrastructure projects
-  STARTUP_PROJECT=$(find . -name "*.Api.csproj" -o -name "*Web.csproj" | head -1)
-  INFRA_PROJECT=$(find . -name "*Infrastructure.csproj" | head -1)
-  [ -z "$INFRA_PROJECT" ] && INFRA_PROJECT="$CSPROJ"
-
-  echo "Project: $PROJECT_NAME"
-  echo "Migrations: $MIGRATIONS_DIR"
-}
-```
-
-### 2. Detect DbContext (Core vs Extensions)
-
-```bash
-detect_dbcontext() {
-  # Priority 1: SmartStack.Domain exists → SmartStack source project (Core only)
-  if find . -type d -name "SmartStack.Domain" | grep -q .; then
-    DBCONTEXT="CoreDbContext"
-    DBCONTEXT_TYPE="core"
-    SCHEMA="core"
-    RUN_BOTH=false
-    echo "DbContext: CoreDbContext (SmartStack.Domain found)"
-    return
-  fi
-
-  # Priority 2: Client project with SmartStack NuGet → BOTH contexts
-  # Detect: csproj files that have a PackageReference to SmartStack (not ProjectReference)
-  # This identifies client projects created via `ss init` that consume SmartStack as NuGet
-  if find . -name "*.csproj" -exec grep -ql "PackageReference.*SmartStack" {} \; 2>/dev/null; then
-    DBCONTEXT="CoreDbContext"
-    DBCONTEXT_TYPE="both"
-    SCHEMA="core"
-    RUN_BOTH=true
-    echo "DbContext: Both (Core from SmartStack NuGet + Extensions local)"
-    echo "  Deploy order: CoreDbContext → ExtensionsDbContext"
-    return
-  fi
-
-  # Priority 3: Scan for DbContext in code
-  CORE_CTX=$(find . -name "*.cs" -exec grep -l "CoreDbContext" {} \; 2>/dev/null | head -1)
-  EXT_CTX=$(find . -name "*.cs" -exec grep -l "ExtensionsDbContext" {} \; 2>/dev/null | head -1)
-
-  if [ -n "$CORE_CTX" ] && [ -n "$EXT_CTX" ]; then
-    DBCONTEXT="CoreDbContext"
-    DBCONTEXT_TYPE="both"
-    SCHEMA="core"
-    RUN_BOTH=true
-    echo "DbContext: Both (CoreDbContext + ExtensionsDbContext found)"
-  elif [ -n "$CORE_CTX" ] && [ -z "$EXT_CTX" ]; then
-    DBCONTEXT="CoreDbContext"
-    DBCONTEXT_TYPE="core"
-    SCHEMA="core"
-    RUN_BOTH=false
-  elif [ -z "$CORE_CTX" ] && [ -n "$EXT_CTX" ]; then
-    DBCONTEXT="ExtensionsDbContext"
-    DBCONTEXT_TYPE="extensions"
-    SCHEMA="extensions"
-    RUN_BOTH=false
-  else
-    # Priority 4: Ask user
-    DBCONTEXT=""
-    DBCONTEXT_TYPE=""
-    SCHEMA=""
-    RUN_BOTH=false
-  fi
-}
-```
-
-### 3. Ask User if DbContext Unknown
+### User Prompt (if DbContext Unknown)
 
 **If `{dbcontext}` is empty after detection:**
 
@@ -188,123 +61,7 @@ if (answer === "CoreDbContext") {
 }
 ```
 
-### 4. Detect Environment
-
-```bash
-detect_environment() {
-  API_DIR=$(find . -type d -name "*.Api" | head -1)
-  [ -z "$API_DIR" ] && API_DIR="src/SmartStack.Api"
-
-  # Priority: --env flag > appsettings.Local.json > error
-  if [ -n "$ENV_FLAG" ]; then
-    CONFIG_FILE="$API_DIR/appsettings.${ENV_FLAG}.json"
-  elif [ -f "$API_DIR/appsettings.Local.json" ]; then
-    CONFIG_FILE="$API_DIR/appsettings.Local.json"
-    SELECTED_ENV="Local"
-  else
-    echo "ERROR: No appsettings.Local.json found"
-    echo "Create one or use --env flag"
-    exit 1
-  fi
-
-  echo "Environment: $SELECTED_ENV"
-  echo "Config: $CONFIG_FILE"
-}
-```
-
-### 5. Determine Base Branch (for squash/rebase)
-
-```bash
-determine_base_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 "ERROR: Cannot run on main/master branch"
-      exit 1
-      ;;
-    *)
-      BASE_BRANCH="develop"
-      BRANCH_TYPE="unknown"
-      ;;
-  esac
-
-  echo "Branch: $CURRENT_BRANCH ($BRANCH_TYPE)"
-  echo "Base: $BASE_BRANCH"
-}
-```
-
-### 6. Block Production
-
-```bash
-block_production() {
-  # Check for production indicators (case-insensitive)
-  if grep -qi '"Production"' "$CONFIG_FILE" 2>/dev/null; then
-    echo "BLOCKED: Production environment detected in $CONFIG_FILE"
-    exit 1
-  fi
-
-  # Case-insensitive database name check
-  DB_LOWER=$(echo "$DATABASE_NAME" | tr '[:upper:]' '[:lower:]')
-  if [[ "$DB_LOWER" == *"prod"* ]] || [[ "$DB_LOWER" == *"production"* ]]; then
-    echo "BLOCKED: Production database detected ($DATABASE_NAME)"
-    exit 1
-  fi
-
-  # Environment name check (case-insensitive)
-  ENV_LOWER=$(echo "$SELECTED_ENV" | tr '[:upper:]' '[:lower:]')
-  if [[ "$ENV_LOWER" == "production" ]] || [[ "$ENV_LOWER" == "prod" ]]; then
-    echo "BLOCKED: Production environment selected ($SELECTED_ENV)"
-    exit 1
-  fi
-}
-```
-
-### 7. Dual Context Helper
-
-```bash
-# Helper for steps that need to run for both contexts when RUN_BOTH=true
-# Usage: run_for_contexts "command_or_function"
-# Executes with CoreDbContext first, then ExtensionsDbContext
-# Maintains deploy order constraint: Core MUST run first
-
-run_for_contexts() {
-  if [ "$RUN_BOTH" = "true" ]; then
-    echo "=== Running for CoreDbContext (core schema) ==="
-    DBCONTEXT="CoreDbContext"
-    DBCONTEXT_TYPE="core"
-    SCHEMA="core"
-    eval "$1"
-
-    echo ""
-    echo "=== Running for ExtensionsDbContext (extensions schema) ==="
-    DBCONTEXT="ExtensionsDbContext"
-    DBCONTEXT_TYPE="extensions"
-    SCHEMA="extensions"
-    eval "$1"
-  else
-    eval "$1"
-  fi
-}
-```
-
-### 8. Display Summary
+### Display Summary
 
 ```
 EF CORE CONTEXT

package/templates/skills/efcore/steps/squash/step-03-create.md

@@ -135,64 +135,7 @@ echo "  Down methods: $DOWN_METHODS"
 
 ### 6. Inject SQL Objects (Functions, Views, SP)
 
-EF Core does NOT generate DDL for TVF, views, and stored procedures.
-SQL source scripts are in `Persistence/SqlObjects/` (Embedded Resources).
-After a squash, they must be re-injected into the consolidated migration.
-
-```bash
-# Check if SqlObjects folder exists with .sql files
-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 ""
-  echo "Found $SQL_FILES SQL object(s) in SqlObjects/"
-  echo "Injecting SqlObjectHelper.ApplyAll(migrationBuilder) into migration..."
-
-  # Validate migration file path before sed operations (prevent path injection)
-  if [ ! -f "$MIGRATION_FILE" ]; then
-    echo "ERROR: Migration file not found: $MIGRATION_FILE"
-    exit 1
-  fi
-  if ! echo "$MIGRATION_FILE" | grep -qE '\.cs$'; then
-    echo "ERROR: Invalid migration file path (not .cs): $MIGRATION_FILE"
-    exit 1
-  fi
-
-  # 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
-  # Find the closing brace of Up() and insert before it
-  sed -i '/protected override void Up/,/^        }/ {
-    /^        }/ i\
-\            // Apply SQL objects (TVF, Views, SP) from embedded resources\
-\            SqlObjectHelper.ApplyAll(migrationBuilder);
-  }' "$MIGRATION_FILE"
-
-  # Verify injection succeeded (fallback to manual step if sed pattern didn't match)
-  if ! grep -q "SqlObjectHelper.ApplyAll" "$MIGRATION_FILE"; then
-    echo "WARNING: Automatic injection failed (indentation pattern may differ)"
-    echo ""
-    echo "MANUAL STEP REQUIRED: Add these lines inside the Up() method before the closing brace:"
-    echo '    using SmartStack.Infrastructure.Persistence.SqlObjects;'
-    echo '    ...'
-    echo '    SqlObjectHelper.ApplyAll(migrationBuilder);'
-    echo ""
-    echo "File: $MIGRATION_FILE"
-  else
-    echo "  SqlObjectHelper.ApplyAll(migrationBuilder) injected"
-  fi
-  find "$SQL_OBJECTS_DIR" -name "*.sql" -exec basename {} \; | while read f; do
-    echo "  - $f"
-  done
-else
-  echo ""
-  echo "No SQL objects found in SqlObjects/ - skipping injection"
-fi
-```
+Load: `references/sql-objects-injection.md`
 
 ---
 

package/templates/skills/feature-full/SKILL.md

@@ -43,7 +43,7 @@ DOMAIN -> APPLICATION -> INFRASTRUCTURE -> API -> WEB
 
 ## Phases 2-7: Implementation
 
-See [steps/step-01-implementation.md](steps/step-01-implementation.md) for detailed code templates covering:
+Start with [steps/step-00-init.md](steps/step-00-init.md) to analyze requirements and existing patterns, then proceed to [steps/step-01-implementation.md](steps/step-01-implementation.md) for detailed code templates covering:
 - Phase 2: Domain (Entity + Factory + Behaviors + Enum)
 - Phase 3: Application (Interface + DTOs + Permissions)
 - Phase 4: Infrastructure (EF Config + Service + DI)

package/templates/skills/feature-full/steps/step-00-init.md

@@ -0,0 +1,57 @@
+# Step 0: Initialization
+
+## YOUR TASK
+Gather requirements and analyze existing code patterns before implementing a complete full-stack feature.
+
+## EXECUTION SEQUENCE
+
+### 1. Identify Feature Scope
+- What is the main entity/aggregate? (e.g., Product, Invoice, Support Ticket)
+- What are the CRUD operations required? (Create, Read, Update, Delete, Archive)
+- What business rules apply? (validations, state transitions, constraints)
+- What user permissions are needed? (who can create/edit/delete/view)
+- What notifications/workflows are required? (emails, webhooks, automation)
+- Does AI play a role? (content generation, analysis, validation)
+
+### 2. Analyze Existing Code Patterns
+- Review `Domain/` for similar entity structures, factories, and behaviors
+- Check `Application/` for existing service interfaces and DTOs
+- Examine `Infrastructure/` for EF Core configurations and patterns
+- Look at `API/Controllers/` for authorization and RequirePermission attributes
+- Study `web/` for similar pages, forms, and i18n implementations
+- Identify reusable components and patterns to follow
+
+### 3. Define Data Model
+- Entity properties and types
+- Enums for status, types, and classifications
+- Relationships (OneToMany, ManyToMany, etc.)
+- Audit requirements (CreatedAt, CreatedBy, ModifiedAt, ModifiedBy)
+- Soft delete or permanent delete?
+
+### 4. Plan Implementation Phases
+- **Phase 2:** Domain entity, factory method, behaviors, enums, IAuditableEntity
+- **Phase 3:** Application service interface, DTOs, permissions (create + assign permissions files)
+- **Phase 4:** Infrastructure (EF Config, concrete service, DI registration, DbSet, migration)
+- **Phase 5:** API controller with Authorize, RequirePermission, ProducesResponseType
+- **Phase 6:** Frontend (API client, custom hook with SignalR, page, form, routing, i18n for 4 languages)
+- **Phase 7:** Integrations (notifications, workflows, AI if applicable)
+
+### 5. Validate Against Architecture Rules
+- Confirm layered architecture is followed (no frontend-to-DB shortcuts)
+- Verify entity factory methods are used (no direct constructors in services)
+- Check permissions split across 2 files (Create/List/Read/Update/Delete vs Assign)
+- Plan SignalR hooks for real-time updates
+- Define ProducesResponseType for all endpoints
+- Plan i18n for English, French, Italian, German
+
+## SUCCESS METRICS
+- Feature scope clearly defined and bounded
+- All required CRUD operations identified
+- Business rules documented
+- Permissions mapped to roles
+- Implementation plan with all 7 phases outlined
+- Existing code patterns understood and will be followed
+- Data model defined with relationships and audit requirements
+
+## NEXT STEP
+Proceed to `./step-01-implementation.md` to execute all phases (Domain, Application, Infrastructure, API, Frontend, Integrations) with code templates and orchestration of child skills.

package/templates/skills/feature-full/steps/step-01-implementation.md

@@ -30,7 +30,7 @@ public record {Entity}Dto(Guid Id, string Name, string Status, DateTime CreatedA
 public record Create{Entity}Request(string Name, string? Description);
 
 // Permissions.cs + PermissionConfiguration.cs (2 files!)
-public const string View = "{context}.{area}.{module}.read";
+public const string View = "{area}.{module}.read";
 ```
 
 ## Phase 4: Infrastructure

package/templates/skills/gitflow/SKILL.md

@@ -10,7 +10,7 @@ disable-model-invocation: true
 - Status: !`git status --short`
 - Recent commits: !`git log --oneline -5`
 - Worktrees: !`git worktree list 2>/dev/null`
-- Config: !`cat .gitflow/config.json 2>/dev/null || echo "no config found"`
+- Config: !`cat .claude/gitflow/config.json 2>/dev/null || echo "no config found"`
 
 <objective>
 Execute GitFlow workflows with automatic versioning, worktree management, and EF Core migration validation. Uses progressive step loading to minimize context and maintain fresh state at each phase.

package/templates/skills/gitflow/_shared.md

@@ -316,6 +316,29 @@ cleanup_worktree_for_branch() {
 
 ---
 
+## VALIDATE_WORKTREE_PATH
+
+Validates that a worktree path follows config conventions. Only `01-Main` and `02-Develop` may use numbered prefixes. All other worktrees (features, releases, hotfixes) MUST use config paths (`features/{name}`, `releases/v{version}`, `hotfixes/{name}`).
+
+```bash
+validate_worktree_path() {
+  local WORKTREE_PATH="$1"
+  local BASENAME=$(basename "$WORKTREE_PATH")
+
+  # Only 01-Main and 02-Develop may use numbered prefixes
+  if [[ "$BASENAME" =~ ^[0-9]{2}- ]] && [[ "$BASENAME" != "01-Main" ]] && [[ "$BASENAME" != "02-Develop" ]]; then
+    echo "ERROR: Invalid numbered worktree directory: $BASENAME"
+    echo "  Path: $WORKTREE_PATH"
+    echo "  FORBIDDEN: Numbered directories like 03-Release, 04-Feature, 05-Hotfix"
+    echo "  REQUIRED: Use config paths → features/{name}, releases/v{version}, hotfixes/{name}"
+    return 1
+  fi
+  return 0
+}
+```
+
+---
+
 ## REPAIR_WORKTREE_PATHS
 
 Repairs worktree metadata files that contain paths from a different platform (e.g., WSL paths `/mnt/d/...` on Windows, or Windows paths `D:/...` on WSL). Scans `.bare/worktrees/*/gitdir` and the corresponding `{worktree}/.git` files.

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,51 @@
+# Worktree and Branch Cleanup
+
+## Clean Up Worktree
+
+```bash
+# 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"
+```