template-loading.sh

#!/usr/bin/env bash
#
# Dev-Control Template Loading Script
# Initialise repositories with standardised templates
# 
# This script copies template files from all *-templates folders in Dev-Control:
#   - docs-templates/      → copied to repo root (with placeholder replacement)
#   - workflows-templates/ → copied to .github/workflows/
#   - licences-templates/  → copied to repo root (future)
#   - Any other *-templates folders added later
#
# USAGE:
#   ./template-loading.sh                    # Interactive mode
#   ./template-loading.sh --files FILE1,FILE2 --overwrite
#   ./template-loading.sh -f CONTRIBUTING.md,SECURITY.md -o
#   ./template-loading.sh --help
#

set -e

# Resolve script location (handles symlinks for global/PATH usage)
SCRIPT_PATH="${BASH_SOURCE[0]}"
while [[ -L "$SCRIPT_PATH" ]]; do
    SCRIPT_DIR="$(cd "$(dirname "$SCRIPT_PATH")" && pwd)"
    SCRIPT_PATH="$(readlink "$SCRIPT_PATH")"
    [[ "$SCRIPT_PATH" != /* ]] && SCRIPT_PATH="$SCRIPT_DIR/$SCRIPT_PATH"
done
SCRIPT_DIR="$(cd "$(dirname "$SCRIPT_PATH")" && pwd)"
DEV_CONTROL_DIR="$(dirname "$SCRIPT_DIR")"
# Fallback if in Dev-Control root
[[ ! -d "$DEV_CONTROL_DIR/docs-templates" ]] && [[ -d "./docs-templates" ]] && DEV_CONTROL_DIR="$(pwd)"

# Source shared libraries
source "$SCRIPT_DIR/lib/colours.sh"
source "$SCRIPT_DIR/lib/print.sh"
source "$SCRIPT_DIR/lib/readme.sh"

# CLI options
CLI_FILES=""
CLI_OVERWRITE=false
CLI_HELP=false
# Use cached/default values and skip config prompts
DEFAULTS_ONLY=false
# Batch mode options
BATCH_MODE=false
REUSE_OWNER=false
ASSUME_YES=false
POSITIONAL_ARGS=()
# Update-only mode: skip dc-init, just update templates on existing repos
UPDATE_ONLY=false
# Include local-only repos (no remote) in update mode
INCLUDE_LOCAL=false
# Directories to skip/exclude in recursive discovery
SKIP_DIRS=()
# Default branch name (detected or overridden via --branch)
DEFAULT_BRANCH=""
# Batch owner prefill control: when true, do not prefill owner prompts with detected ORG_NAME
BATCH_SKIP_OWNER=false
# Reuse templates/settings across the batch
BATCH_REUSE_TEMPLATES=false
BATCH_SELECTED_CHOICES=""
BATCH_LICENSE_TYPE=""
BATCH_STABILITY=""
BATCH_STABILITY_COLOR=""
# Creation queue for batch mode
CREATE_QUEUE=()

# ============================================================================
# CLI ARGUMENT PARSING
# ============================================================================

show_help() {
    echo -e "${BOLD}Dev-Control Template Loader${NC}"
    echo ""
    echo "Usage: $(basename "$0") [OPTIONS]"
    echo ""
    echo "Options:"
    echo "  -f, --files FILE1,FILE2    Only process specific files (comma-separated)"
    echo "  -o, --overwrite            Overwrite existing files without prompting"
    echo "      --defaults             Use cached/default values and skip config prompts (template selection still shown)"
    echo "  -b, --batch                Batch mode: initialise multiple repositories (provide directories or use '*' to select all subdirs)"
    echo "  -u, --update               Update mode: skip dc-init, only install templates on existing repos (stash/pull/install/commit/push)"
    echo "      --update-only          Alias for --update"
    echo "      --local                Include repos without a remote in update mode (skipped by default)"
    echo "      --exclude DIR [DIR..]   Exclude directories (and their children) from batch/update discovery"
    echo "      --skip DIR [DIR..]      Alias for --exclude"
    echo "      --branch NAME          Override default branch name (default: main)"
    echo "      --reuse-owner          Prompt for repository owner once and reuse for all repos in the batch"
    echo "      --push                 Commit and push template changes after install (amends prior dc-init commit if present)"
    echo "  -y, --yes                  Assume defaults and run non-interactively in batch mode"
    echo "  -h, --help                 Show this help message"
    echo ""
    echo "Examples:"
    echo "  $(basename "$0")                                    # Interactive mode"
    echo "  $(basename "$0") -f CONTRIBUTING.md -o              # Update single file"
    echo "  $(basename "$0") --files README.md,SECURITY.md      # Update multiple files"
    echo "  $(basename "$0") -f LICENSE -o                      # Update licence"
    echo ""
    echo "Available template files:"
    for dir in "$DEV_CONTROL_DIR"/*-templates; do
        if [[ -d "$dir" ]]; then
            echo "  $(basename "$dir"):"
            for file in "$dir"/*; do
                [[ -f "$file" ]] && echo "    - $(basename "$file")"
            done
        fi
    done
}

parse_args() {
    POSITIONAL_ARGS=()
    while [[ $# -gt 0 ]]; do
        case "$1" in
            -f|--files)
                CLI_FILES="$2"
                shift 2
                ;;
            -o|--overwrite)
                CLI_OVERWRITE=true
                shift
                ;;
            --defaults)
                DEFAULTS_ONLY=true
                shift
                ;;
            -b|--batch)
                BATCH_MODE=true
                shift
                ;;
            -u|--update|--update-only)
                UPDATE_ONLY=true
                BATCH_MODE=true
                shift
                ;;
            --local)
                INCLUDE_LOCAL=true
                shift
                ;;
            --skip|--exclude)
                shift
                while [[ $# -gt 0 && ! "$1" =~ ^- ]]; do
                    SKIP_DIRS+=("$1")
                    shift
                done
                ;;
            --branch)
                DEFAULT_BRANCH="$2"
                shift 2
                ;;
            --reuse-owner)
                REUSE_OWNER=true
                shift
                ;;
            --push)
                AUTO_PUSH=true
                shift
                ;;
            -y|--yes)
                ASSUME_YES=true
                shift
                ;;
            -h|--help)
                CLI_HELP=true
                shift
                ;;
            --) # end of options
                shift
                break
                ;;
            -*)
                print_error "Unknown option: $1"
                echo "Use --help for usage information"
                exit 1
                ;;
            *)
                POSITIONAL_ARGS+=("$1")
                shift
                ;;
        esac
    done
} 

# ============================================================================
# HELPER FUNCTIONS
# ============================================================================

# Build TEMPLATE_FOLDERS mapping without displaying the interactive menu
# Must be called before install_templates or describe_template_choices
build_template_folders() {
    local idx=1
    declare -gA TEMPLATE_FOLDERS
    [[ -d "$DEV_CONTROL_DIR/docs-templates" ]]      && { TEMPLATE_FOLDERS[$idx]="docs";      ((idx++)) || true; }
    [[ -d "$DEV_CONTROL_DIR/workflows-templates" ]]  && { TEMPLATE_FOLDERS[$idx]="workflows";  ((idx++)) || true; }
    [[ -d "$DEV_CONTROL_DIR/actions-templates" ]]    && { TEMPLATE_FOLDERS[$idx]="actions";    ((idx++)) || true; }
    [[ -d "$DEV_CONTROL_DIR/github-templates" ]]     && { TEMPLATE_FOLDERS[$idx]="github";     ((idx++)) || true; }
    if [[ -d "$DEV_CONTROL_DIR/licence-templates" ]] || [[ -d "$DEV_CONTROL_DIR/licences-templates" ]]; then
        TEMPLATE_FOLDERS[$idx]="licences"
        ((idx++)) || true
    fi
    for dir in "$DEV_CONTROL_DIR"/*-templates; do
        if [[ -d "$dir" ]]; then
            local name
            name=$(basename "$dir")
            if [[ "$name" != "docs-templates" && "$name" != "workflows-templates" && "$name" != "actions-templates" && "$name" != "licence-templates" && "$name" != "licences-templates" && "$name" != "github-templates" ]]; then
                TEMPLATE_FOLDERS[$idx]="${name%-templates}"
                ((idx++)) || true
            fi
        fi
    done
}

# Translate template selection string to human-readable names e.g. "2,3" → "workflows, actions" | "A" → "all templates"
describe_template_choices() {
    local selection="$1"
    if [[ "$selection" =~ [Aa] ]]; then
        echo "all templates"
        return
    fi
    local names=()
    local IFS=','
    for token in $selection; do
        # Strip any letter suffixes (e.g. "1AX" → "1")
        local num="${token%%[A-Za-z]*}"
        if [[ -n "$num" && -n "${TEMPLATE_FOLDERS[$num]+x}" ]]; then
            local name="${TEMPLATE_FOLDERS[$num]}"
            # Avoid duplicates
            local already=false
            for n in "${names[@]}"; do
                [[ "$n" == "$name" ]] && already=true
            done
            $already || names+=("$name")
        fi
    done
    if [[ ${#names[@]} -eq 0 ]]; then
        echo "templates"
    else
        local IFS=', '
        echo "${names[*]}"
    fi
}

# Check if we're in a git repository with a LOCAL .git folder
check_git_repo() {
    # Check for local .git directory (not inherited from parent)
    if [[ ! -d ".git" ]]; then
        print_warning "No local .git directory. Initialising..."
        git init -b "${DEFAULT_BRANCH:-main}"
        git config user.email "${GIT_EMAIL:-noreply@github.com}" 2>/dev/null || true
        git config user.name "${GIT_NAME:-User}" 2>/dev/null || true
        print_success "Repository initialised (branch: ${DEFAULT_BRANCH:-main})"
        echo ""
    else
        # Existing repo: check if current branch matches expected default
        local current_branch
        current_branch=$(git symbolic-ref --short HEAD 2>/dev/null || echo "")
        if [[ -n "$current_branch" && -n "$DEFAULT_BRANCH" && "$current_branch" != "$DEFAULT_BRANCH" ]]; then
            # Only warn on first commit (no parent commits means fresh repo)
            local commit_count
            commit_count=$(git rev-list --count HEAD 2>/dev/null || echo "0")
            if [[ "$commit_count" -le 1 ]]; then
                print_warning "Current branch '$current_branch' differs from expected '$DEFAULT_BRANCH'"
                if [[ "$DEFAULTS_ONLY" != "true" ]]; then
                    read -rp "Rename '$current_branch' to '$DEFAULT_BRANCH'? [Y/n]: " rename_branch
                    if [[ "${rename_branch:-y}" =~ [Yy] ]]; then
                        git branch -m "$current_branch" "$DEFAULT_BRANCH"
                        print_success "Branch renamed to $DEFAULT_BRANCH"
                    fi
                else
                    git branch -m "$current_branch" "$DEFAULT_BRANCH"
                    print_success "Branch renamed to $DEFAULT_BRANCH"
                fi
            fi
        fi
    fi
}

# Detect licence type from the LICENSE/LICENCE file in the current directory
detect_license_from_file() {
    local license_file=""
    for f in LICENSE LICENCE LICENSE.md LICENCE.md LICENSE.txt LICENCE.txt; do
        [[ -f "$f" ]] && { license_file="$f"; break; }
    done
    [[ -z "$license_file" ]] && return

    local head
    head=$(head -5 "$license_file" 2>/dev/null || true)

    if [[ "$head" == *"GNU GENERAL PUBLIC LICENSE"* && "$head" == *"Version 3"* ]]; then
        LICENSE_TYPE="GPL-3.0"
    elif [[ "$head" == *"Apache"* && "$head" == *"Version 2.0"* ]]; then
        LICENSE_TYPE="Apache-2.0"
    elif [[ "$head" == *"MIT"* ]]; then
        LICENSE_TYPE="MIT"
    elif [[ "$head" == *"BSD 3-Clause"* ]]; then
        LICENSE_TYPE="BSD-3-Clause"
    elif [[ "$head" == *"GNU GENERAL PUBLIC LICENSE"* && "$head" == *"Version 2"* ]]; then
        LICENSE_TYPE="GPL-2.0"
    elif [[ "$head" == *"Mozilla Public License"* && "$head" == *"2.0"* ]]; then
        LICENSE_TYPE="MPL-2.0"
    elif [[ "$head" == *"ISC"* ]]; then
        LICENSE_TYPE="ISC"
    else
        return
    fi
    print_info "Detected licence from $license_file: $LICENSE_TYPE"
}

# Try to get git user info from global config
get_git_user_info() {
    GIT_NAME=$(git config --global user.name 2>/dev/null || echo "")
    GIT_EMAIL=$(git config --global user.email 2>/dev/null || echo "")
}

# Get repository information
get_repo_info() {
    # Try to get remote URL
    REPO_URL=$(git config --get remote.origin.url 2>/dev/null || echo "")
    
    if [[ -n "$REPO_URL" ]]; then
        # Extract org/repo from URL
        if [[ "$REPO_URL" =~ github\.com[:/]([^/]+)/([^/.]+) ]]; then
            ORG_NAME="${BASH_REMATCH[1]}"
            REPO_SLUG="${BASH_REMATCH[2]}"
            REPO_URL="https://github.com/$ORG_NAME/$REPO_SLUG"
        else
            ORG_NAME=""
            REPO_SLUG=$(basename "$(pwd)")
        fi
    else
        ORG_NAME=""
        REPO_SLUG=$(basename "$(pwd)")
        REPO_URL=""
    fi
    
    # Try to prefill GitHub username from gh CLI if not detected from remote
    if [[ -z "$ORG_NAME" ]] && command -v gh &>/dev/null; then
        local gh_user
        gh_user=$(gh api user --jq .login 2>/dev/null || true)
        if [[ "$gh_user" =~ ^[A-Za-z0-9-]+$ ]]; then
            ORG_NAME="$gh_user"
            print_info "Detected GitHub user from gh CLI: $ORG_NAME"
        elif [[ -n "$gh_user" ]]; then
            print_warning "gh CLI returned unexpected output; skipping auto-detected owner"
        fi
    fi

    # Load cached metadata from git config FIRST (set by previous dc-init runs)
    # Only load from LOCAL config if a local .git directory exists
    if [[ -d ".git" ]]; then
        local cached_licence
        cached_licence=$(git config --local dc-init.licence-type 2>/dev/null || echo "")
        if [[ -n "$cached_licence" ]]; then
            LICENSE_TYPE="$cached_licence"
            print_info "Loaded licence from git config: $LICENSE_TYPE"
        fi
        
        local cached_org
        cached_org=$(git config --local dc-init.org-name 2>/dev/null || echo "")
        if [[ -n "$cached_org" ]]; then
            ORG_NAME="$cached_org"
        fi
        
        local cached_description
        cached_description=$(git config --local dc-init.description 2>/dev/null || echo "")
        if [[ -n "$cached_description" ]]; then
            SHORT_DESCRIPTION="$cached_description"
        fi
        
        local cached_website
        cached_website=$(git config --local dc-init.website-url 2>/dev/null || echo "")
        if [[ -n "$cached_website" ]]; then
            WEBSITE_URL="$cached_website"
            print_info "Loaded website URL from git config: $WEBSITE_URL"
        fi
        
        local cached_bot_name
        cached_bot_name=$(git config --local dc-init.bot-name 2>/dev/null || echo "")
        if [[ -n "$cached_bot_name" ]]; then
            BOT_NAME="$cached_bot_name"
        fi
        
        local cached_bot_email
        cached_bot_email=$(git config --local dc-init.bot-email 2>/dev/null || echo "")
        if [[ -n "$cached_bot_email" ]]; then
            BOT_EMAIL="$cached_bot_email"
        fi

        local cached_bot_app_id_secret
        cached_bot_app_id_secret=$(git config --local dc-init.bot-app-id-secret 2>/dev/null || echo "")
        if [[ -n "$cached_bot_app_id_secret" ]]; then
            BOT_APP_ID_SECRET="$cached_bot_app_id_secret"
        fi

        local cached_bot_private_key_secret
        cached_bot_private_key_secret=$(git config --local dc-init.bot-private-key-secret 2>/dev/null || echo "")
        if [[ -n "$cached_bot_private_key_secret" ]]; then
            BOT_PRIVATE_KEY_SECRET="$cached_bot_private_key_secret"
        fi
        
        local cached_gpg_private_key_secret
        cached_gpg_private_key_secret=$(git config --local dc-init.gpg-private-key-secret 2>/dev/null || echo "")
        if [[ -n "$cached_gpg_private_key_secret" ]]; then
            GPG_PRIVATE_KEY_SECRET="$cached_gpg_private_key_secret"
        fi
        
        local cached_gpg_passphrase_secret
        cached_gpg_passphrase_secret=$(git config --local dc-init.gpg-passphrase-secret 2>/dev/null || echo "")
        if [[ -n "$cached_gpg_passphrase_secret" ]]; then
            GPG_PASSPHRASE_SECRET="$cached_gpg_passphrase_secret"
        fi
        
        local cached_user_token_secret
        cached_user_token_secret=$(git config --local dc-init.user-token-secret 2>/dev/null || echo "")
        if [[ -n "$cached_user_token_secret" ]]; then
            USER_TOKEN_SECRET="$cached_user_token_secret"
        fi
        
        local cached_security_app_id_secret
        cached_security_app_id_secret=$(git config --local dc-init.security-app-id-secret 2>/dev/null || echo "")
        if [[ -n "$cached_security_app_id_secret" ]]; then
            SECURITY_APP_ID_SECRET="$cached_security_app_id_secret"
        fi
        
        local cached_security_private_key_secret
        cached_security_private_key_secret=$(git config --local dc-init.security-private-key-secret 2>/dev/null || echo "")
        if [[ -n "$cached_security_private_key_secret" ]]; then
            SECURITY_PRIVATE_KEY_SECRET="$cached_security_private_key_secret"
        fi
        
        local cached_stability
        cached_stability=$(git config --local dc-init.stability 2>/dev/null || echo "")
        if [[ -n "$cached_stability" ]]; then
            STABILITY="$cached_stability"
        fi
        
        local cached_stability_color
        cached_stability_color=$(git config --local dc-init.stability-colour 2>/dev/null || echo "")
        if [[ -n "$cached_stability_color" ]]; then
            STABILITY_COLOR="$cached_stability_color"
        fi
    fi

    # Load global defaults from repoVars.env (if it exists) repoVars.env OVERRIDES git config — it represents the org-wide standard
    local global_vars_file="$DEV_CONTROL_DIR/config/profiles/repoVars.env"
    if [[ -f "$global_vars_file" ]]; then
        # shellcheck source=/dev/null
        source "$global_vars_file"
        print_info "Loaded global defaults from repoVars.env"
    fi

    # If we have an org and repo slug, try to fetch repo metadata from GitHub (only if not cached)
    if [[ -n "$ORG_NAME" && -n "$REPO_SLUG" ]] && command -v gh &>/dev/null; then
        # Try to detect repository description from GitHub (if not already cached)
        if [[ -z "$SHORT_DESCRIPTION" ]]; then
            local gh_desc
            gh_desc=$(gh repo view "${ORG_NAME}/${REPO_SLUG}" --json description --jq .description 2>/dev/null || true)
            if [[ -n "$gh_desc" && "$gh_desc" != "null" ]]; then
                SHORT_DESCRIPTION="$gh_desc"
                print_info "Detected GitHub description: $SHORT_DESCRIPTION"
            fi
        fi

        # Try to detect licence from GitHub (if not already cached)
        if [[ -z "$LICENSE_TYPE" ]]; then
            local gh_licence
            gh_licence=$(gh repo view "${ORG_NAME}/${REPO_SLUG}" --json licenseInfo --jq '.licenseInfo.key' 2>/dev/null || true)
            if [[ -n "$gh_licence" && "$gh_licence" != "null" ]]; then
                # Map gh key to SPDX identifier
                case "$gh_licence" in
                    gpl-3.0)        LICENSE_TYPE="GPL-3.0" ;;
                    gpl-2.0)        LICENSE_TYPE="GPL-2.0" ;;
                    apache-2.0)     LICENSE_TYPE="Apache-2.0" ;;
                    mit)            LICENSE_TYPE="MIT" ;;
                    bsd-3-clause)   LICENSE_TYPE="BSD-3-Clause" ;;
                    bsd-2-clause)   LICENSE_TYPE="BSD-2-Clause" ;;
                    mpl-2.0)        LICENSE_TYPE="MPL-2.0" ;;
                    isc)            LICENSE_TYPE="ISC" ;;
                    *)              LICENSE_TYPE="$gh_licence" ;;
                esac
                print_info "Detected GitHub licence: $LICENSE_TYPE"
            fi
        fi
    fi

    # Fallback: detect from LICENCE file in current directory
    if [[ -z "$LICENSE_TYPE" ]]; then
        detect_license_from_file
    fi

    PROJECT_NAME="${REPO_SLUG}"
}

# ============================================================================
# TEMPLATE PROCESSING
# ============================================================================

collect_project_info() {
    # Quick exit if batch reusing config and this is not the first repo
    # BUT: description is always per-repo, so we must ask it separately below
    local skip_shared_config=false
    if [[ "$BATCH_REUSE_TEMPLATES" == "true" && -n "$BATCH_SELECTED_CHOICES" ]]; then
        skip_shared_config=true
        print_info "Skipping shared config (using initialisation config)"
    fi
    
    echo -e "${BOLD}Project Configuration${NC}"
    
    # Project name
    read -rp "Project name [$PROJECT_NAME]: " input
    PROJECT_NAME="${input:-$PROJECT_NAME}"
    
    # Repository slug
    read -rp "Repository slug [$REPO_SLUG]: " input
    REPO_SLUG="${input:-$REPO_SLUG}"
    
    # Repository owner (GitHub username or organisation) — allow overriding detected value
    if [[ "$BATCH_MODE" == "true" && "$REUSE_OWNER" == "true" ]]; then
        # Shared owner was selected for the batch; skip per-repo prompting and use shared value
        REPO_OWNER="${REPO_OWNER}"
        print_info "Using shared repository owner: $REPO_OWNER"
        if [[ -n "$ORG_NAME" && "$ORG_NAME" != "$REPO_OWNER" ]]; then
            print_warning "Detected remote owner '$ORG_NAME' differs from chosen shared owner '$REPO_OWNER'"
        fi
    elif [[ "$BATCH_MODE" == "true" && "$BATCH_SKIP_OWNER" == "true" ]]; then
        # In batch non-shared mode we do not prefill owner prompt with detected ORG_NAME
        read -rp "Repository owner (user/org): " input
        REPO_OWNER="${input:-$ORG_NAME}"
        if [[ -n "$ORG_NAME" && -n "$REPO_OWNER" && "$REPO_OWNER" != "$ORG_NAME" ]]; then
            print_warning "Detected remote owner '$ORG_NAME' differs from entered owner '$REPO_OWNER'"
        fi
    else
        if [[ -z "$ORG_NAME" ]]; then
            read -rp "Repository owner (user/org): " REPO_OWNER
            REPO_OWNER="${REPO_OWNER:-$ORG_NAME}"
        else
            read -rp "Repository owner (user/org) [${ORG_NAME}]: " input
            REPO_OWNER="${input:-$ORG_NAME}"
        fi
    fi

    # Mirror back to ORG_NAME for compatibility with older code paths
    ORG_NAME="$REPO_OWNER"

    # Repository URL (constructed from chosen owner)
    REPO_URL="https://github.com/$REPO_OWNER/$REPO_SLUG"
    read -rp "Repository URL [$REPO_URL]: " input
    REPO_URL="${input:-$REPO_URL}"
    
    # Website URL — auto-detect from domain-like repo slugs
    if [[ -z "$WEBSITE_URL" ]]; then
        # Check if repo slug looks like a domain (contains dots)
        if [[ "$REPO_SLUG" =~ \. ]]; then
            WEBSITE_URL="https://$REPO_SLUG"
            print_info "Detected website URL from repo slug: $WEBSITE_URL"
        fi
    fi
    if [[ -n "$WEBSITE_URL" ]]; then
        read -rp "Website URL [$WEBSITE_URL]: " input
        WEBSITE_URL="${input:-$WEBSITE_URL}"
    else
        read -rp "Website URL (optional): " WEBSITE_URL
    fi
    
    # Short description — ALWAYS asked per-repo, never shared in batch mode
    # Prefill from THIS repo's cached config (loaded by get_repo_info)
    if [[ -n "$SHORT_DESCRIPTION" ]]; then
        read -rp "Short description [$SHORT_DESCRIPTION]: " input
        SHORT_DESCRIPTION="${input:-$SHORT_DESCRIPTION}"
    else
        read -rp "Short description: " SHORT_DESCRIPTION
    fi
    
    # Long description
    echo "Long description (press Enter twice when done):"
    LONG_DESCRIPTION=""
    while IFS= read -r line; do
        [[ -z "$line" ]] && break
        LONG_DESCRIPTION+="$line\n"
    done
    LONG_DESCRIPTION="${LONG_DESCRIPTION:-$SHORT_DESCRIPTION}"
    
    # If not reusing batch config, ask for licence and stability per-repo
    if [[ "$skip_shared_config" != "true" ]]; then
        echo ""
        echo "Select licence type:"
        echo "  1) MIT"
        echo "  2) Apache-2.0"
        echo "  3) GPL-3.0"
        echo "  4) BSD-3-Clause"
        echo "  5) Other"
        # Determine default from detected LICENSE_TYPE
        local default_licence_choice=1
        if [[ -n "$LICENSE_TYPE" ]]; then
            case "${LICENSE_TYPE,,}" in
                mit) default_licence_choice=1 ;;
                apache*|apache-2.0) default_licence_choice=2 ;;
                gpl*|gpl-3.0) default_licence_choice=3 ;;
                bsd*|bsd-3-clause) default_licence_choice=4 ;;
                *) default_licence_choice=5 ;;
            esac
            print_info "Detected licence: $LICENSE_TYPE (will be used if you leave blank)"
        fi
        read -rp "Choice [${default_licence_choice}]: " licence_choice
        case "${licence_choice:-$default_licence_choice}" in
            1) LICENSE_TYPE="MIT" ;;
            2) LICENSE_TYPE="Apache-2.0" ;;
            3) LICENSE_TYPE="GPL-3.0" ;;
            4) LICENSE_TYPE="BSD-3-Clause" ;;
            5) 
                read -rp "Enter licence name [${LICENSE_TYPE:-}]: " custom_licence
                LICENSE_TYPE="${custom_licence:-$LICENSE_TYPE}"
                ;;
        esac
        
        # Stability — use cached value as default if available
        echo ""
        echo "Select stability level:"
        echo "  1) experimental (orange)"
        echo "  2) beta (yellow)"
        echo "  3) stable (green)"
        echo "  4) mature (blue)"
        local default_stability_choice=1
        if [[ -n "$STABILITY" ]]; then
            case "${STABILITY,,}" in
                experimental) default_stability_choice=1 ;;
                beta) default_stability_choice=2 ;;
                stable) default_stability_choice=3 ;;
                mature) default_stability_choice=4 ;;
                *) default_stability_choice=1 ;;
            esac
        fi
        read -rp "Choice [${default_stability_choice}]: " stability_choice
        case "${stability_choice:-$default_stability_choice}" in
            1) STABILITY="experimental"; STABILITY_COLOR="orange" ;;
            2) STABILITY="beta"; STABILITY_COLOR="yellow" ;;
            3) STABILITY="stable"; STABILITY_COLOR="green" ;;
            4) STABILITY="mature"; STABILITY_COLOR="blue" ;;
            *) STABILITY="experimental"; STABILITY_COLOR="orange" ;;
        esac
    fi
    
    # Bot configuration (for actions/workflows that need bot identity)
    echo ""
    echo "Bot configuration (optional - for GitHub Actions identity setup):"
    if [[ -n "$BOT_NAME" ]]; then
        read -rp "Bot name [$BOT_NAME]: " input
        BOT_NAME="${input:-$BOT_NAME}"
    else
        read -rp "Bot name (optional, e.g., my-bot): " BOT_NAME
    fi
    
    if [[ -n "$BOT_EMAIL" ]]; then
        read -rp "Bot email [$BOT_EMAIL]: " input
        BOT_EMAIL="${input:-$BOT_EMAIL}"
    else
        if [[ -n "$BOT_NAME" ]]; then
            # Try to construct a default bot email suggestion
            local suggested_email="${BOT_NAME}@users.noreply.github.com"
            read -rp "Bot email (e.g., 12345+${BOT_NAME}@users.noreply.github.com): " BOT_EMAIL
        else
            read -rp "Bot email (optional): " BOT_EMAIL
        fi
    fi

    if [[ -n "$BOT_APP_ID_SECRET" ]]; then
        read -rp "Bot app-id [$BOT_APP_ID_SECRET]: " input
        BOT_APP_ID_SECRET="${input:-$BOT_APP_ID_SECRET}"
    else
        read -rp "Bot app-id (secret name, e.g. MY_BOT_APP_ID): " BOT_APP_ID_SECRET
    fi

    if [[ -n "$BOT_PRIVATE_KEY_SECRET" ]]; then
        read -rp "Bot private-key [$BOT_PRIVATE_KEY_SECRET]: " input
        BOT_PRIVATE_KEY_SECRET="${input:-$BOT_PRIVATE_KEY_SECRET}"
    else
        read -rp "Bot private-key (secret name, e.g. MY_BOT_PRIVATE_KEY): " BOT_PRIVATE_KEY_SECRET
    fi
    
    if [[ -n "$GPG_PRIVATE_KEY_SECRET" ]]; then
        read -rp "Bot gpg-private-key [$GPG_PRIVATE_KEY_SECRET]: " input
        GPG_PRIVATE_KEY_SECRET="${input:-$GPG_PRIVATE_KEY_SECRET}"
    else
        read -rp "Bot gpg-private-key (secret name, e.g. MY_GPG_KEY): " GPG_PRIVATE_KEY_SECRET
    fi
    
    if [[ -n "$GPG_PASSPHRASE_SECRET" ]]; then
        read -rp "Bot gpg-passphrase [$GPG_PASSPHRASE_SECRET]: " input
        GPG_PASSPHRASE_SECRET="${input:-$GPG_PASSPHRASE_SECRET}"
    else
        read -rp "Bot gpg-passphrase (secret name, e.g. MY_GPG_PASSPHRASE): " GPG_PASSPHRASE_SECRET
    fi
    
    if [[ -n "$USER_TOKEN_SECRET" ]]; then
        read -rp "Bot user-token [$USER_TOKEN_SECRET]: " input
        USER_TOKEN_SECRET="${input:-$USER_TOKEN_SECRET}"
    else
        read -rp "Bot user-token (secret name, e.g. MY_GITHUB_TOKEN): " USER_TOKEN_SECRET
    fi
    
    if [[ -n "$SECURITY_APP_ID_SECRET" ]]; then
        read -rp "Security app-id [$SECURITY_APP_ID_SECRET]: " input
        SECURITY_APP_ID_SECRET="${input:-$SECURITY_APP_ID_SECRET}"
    else
        read -rp "Security app-id (secret name, e.g. SECURITY_APP_ID): " SECURITY_APP_ID_SECRET
    fi
    
    if [[ -n "$SECURITY_PRIVATE_KEY_SECRET" ]]; then
        read -rp "Security private-key [$SECURITY_PRIVATE_KEY_SECRET]: " input
        SECURITY_PRIVATE_KEY_SECRET="${input:-$SECURITY_PRIVATE_KEY_SECRET}"
    else
        read -rp "Security private-key (secret name, e.g. SECURITY_PRIVATE_KEY): " SECURITY_PRIVATE_KEY_SECRET
    fi
    
    CURRENT_YEAR=$(date +%Y)
}

process_template() {
    local src="$1"
    local dest="$2"
    
    if [[ ! -f "$src" ]]; then
        print_warning "Template not found: $src"
        return 1
    fi
    
    mkdir -p "$(dirname "$dest")"
    
    # Copy and replace placeholders
    sed -e "s|{{PROJECT_NAME}}|$PROJECT_NAME|g" \
        -e "s|{{REPO_SLUG}}|$REPO_SLUG|g" \
        -e "s|{{ORG_NAME}}|$ORG_NAME|g" \
        -e "s|{{REPO_URL}}|$REPO_URL|g" \
        -e "s|{{SHORT_DESCRIPTION}}|$SHORT_DESCRIPTION|g" \
        -e "s|{{LONG_DESCRIPTION}}|$LONG_DESCRIPTION|g" \
        -e "s|{{LICENSE_TYPE}}|$LICENSE_TYPE|g" \
        -e "s|{{STABILITY}}|$STABILITY|g" \
        -e "s|{{STABILITY_COLOR}}|$STABILITY_COLOR|g" \
        -e "s|{{CURRENT_YEAR}}|$CURRENT_YEAR|g" \
        -e "s|{{BOT_NAME}}|${BOT_NAME:-}|g" \
        -e "s|{{BOT_EMAIL}}|${BOT_EMAIL:-}|g" \
        -e "s|{{BOT_APP_ID_SECRET}}|${BOT_APP_ID_SECRET:-}|g" \
        -e "s|{{BOT_PRIVATE_KEY_SECRET}}|${BOT_PRIVATE_KEY_SECRET:-}|g" \
        -e "s|{{GPG_PRIVATE_KEY_SECRET}}|${GPG_PRIVATE_KEY_SECRET:-}|g" \
        -e "s|{{GPG_PASSPHRASE_SECRET}}|${GPG_PASSPHRASE_SECRET:-}|g" \
        -e "s|{{USER_TOKEN_SECRET}}|${USER_TOKEN_SECRET:-}|g" \
        -e "s|{{SECURITY_APP_ID_SECRET}}|${SECURITY_APP_ID_SECRET:-}|g" \
        -e "s|{{SECURITY_PRIVATE_KEY_SECRET}}|${SECURITY_PRIVATE_KEY_SECRET:-}|g" \
        "$src" > "$dest"
    
    print_success "Created: $dest"
}

# ============================================================================
# TEMPLATE DISCOVERY
# ============================================================================

discover_template_folders() {
    local folders=()
    for dir in "$DEV_CONTROL_DIR"/*-templates; do
        if [[ -d "$dir" ]]; then
            folders+=("$dir")
        fi
    done
    echo "${folders[@]}"
}

get_folder_display_name() {
    local folder="$1"
    local name=$(basename "$folder")
    name="${name%-templates}"
    echo "${name^}"
}

# ============================================================================
# TEMPLATE SELECTION
# ============================================================================

select_templates() {
    echo ""
    echo -e "${BOLD}Select templates to install:${NC}\n"
    
    local idx=1
    declare -gA TEMPLATE_FOLDERS
    
    # docs-templates
    if [[ -d "$DEV_CONTROL_DIR/docs-templates" ]]; then
        echo -e "  ${CYAN}$idx)${NC} Documentation       - README, CONTRIBUTING, CODE_OF_CONDUCT, SECURITY  (→ docs/)"
        echo -e "     ${YELLOW}Sub-options:${NC} A) README AX) README, BADGES ONLY B) CONTRIBUTING  C) CODE_OF_CONDUCT  D) SECURITY "
        TEMPLATE_FOLDERS[$idx]="docs"
        ((idx++))
    fi
    
    # workflows-templates  
    if [[ -d "$DEV_CONTROL_DIR/workflows-templates" ]]; then
        echo -e "  ${CYAN}$idx)${NC} Workflows           - GitHub Actions (→ .github/workflows/)"
        TEMPLATE_FOLDERS[$idx]="workflows"
        ((idx++))
    fi
    
    # actions-templates
    if [[ -d "$DEV_CONTROL_DIR/actions-templates" ]]; then
        echo -e "  ${CYAN}$idx)${NC} Actions             - Composite Actions (→ .github/actions/)"
        TEMPLATE_FOLDERS[$idx]="actions"
        ((idx++))
    fi
    
    # github-templates (issue templates, PR template)
    if [[ -d "$DEV_CONTROL_DIR/github-templates" ]]; then
        echo -e "  ${CYAN}$idx)${NC} GitHub Templates    - Issue & PR templates (→ .github/)"
        TEMPLATE_FOLDERS[$idx]="github"
        ((idx++))
    fi
    
    # licence-templates (or licences-templates)
    if [[ -d "$DEV_CONTROL_DIR/licence-templates" ]] || [[ -d "$DEV_CONTROL_DIR/licences-templates" ]]; then
        echo -e "  ${CYAN}$idx)${NC} Licences            - LICENSE file"
        TEMPLATE_FOLDERS[$idx]="licences"
        ((idx++))
    fi
    
    # Any other *-templates folders
    for dir in "$DEV_CONTROL_DIR"/*-templates; do
        if [[ -d "$dir" ]]; then
            local name=$(basename "$dir")
            if [[ "$name" != "docs-templates" && "$name" != "workflows-templates" && "$name" != "actions-templates" && "$name" != "licence-templates" && "$name" != "licences-templates" && "$name" != "github-templates" ]]; then
                local display=$(get_folder_display_name "$dir")
                echo -e "  ${CYAN}$idx)${NC} $display"
                TEMPLATE_FOLDERS[$idx]="${name%-templates}"
                ((idx++))
            fi
        fi
    done
    
    echo ""
    echo -e "  ${GREEN}A)${NC} Install ALL templates"
    echo -e "  ${YELLOW}Q)${NC} Quit"
    echo ""
    
    read -rp "Enter choices (e.g., 1AX, 1C, 1D, 2, 3, 4): " selection
    # Store selection in global variable (avoids subshell issues)
    SELECTED_TEMPLATE_CHOICES="$selection"
}

install_templates() {
    local selection="$1"
    local target_dir
    target_dir=$(pwd)
    
    # Track if installing all (for auto-licence selection)
    local install_all=false
    
    # Handle 'A' for all
    if [[ "$selection" =~ [Aa] ]]; then
        install_all=true
        selection=""
        for key in "${!TEMPLATE_FOLDERS[@]}"; do
            selection+="$key,"
        done
        selection="${selection%,}"
    fi
    
    # Handle quit
    if [[ "$selection" =~ [Qq] ]]; then
        print_info "Installation cancelled."
        exit 0
    fi
    
    IFS=',' read -ra SELECTED <<< "$selection"

    for rawsel in "${SELECTED[@]}"; do
        sel=$(echo "$rawsel" | tr -d ' ')
        # parse numeric and letter suffix (e.g., 1, 1A, 1AX)
        if [[ "$sel" =~ ^([0-9]+)([A-Za-z]+)$ ]]; then
            num="${BASH_REMATCH[1]}"
            suffix="${BASH_REMATCH[2]}"
        else
            num="$sel"
            suffix=""
        fi
        folder_type="${TEMPLATE_FOLDERS[$num]}"
        
        if [[ "$folder_type" == "docs" && -n "$suffix" ]]; then
            # If suffix contains X -> add badges after title
            if [[ "$suffix" =~ [Xx] ]]; then
                readme_insert_badges "$target_dir/docs/README.md"
                # if only X present, continue to next selection
                if [[ ! "$suffix" =~ [AaBbCcDd] ]]; then
                    continue
                fi
            fi
            # Map letters to specific doc files
            declare -a docs_files=()
            [[ "$suffix" =~ [Aa] ]] && docs_files+=("README.md")
            [[ "$suffix" =~ [Bb] ]] && docs_files+=("CONTRIBUTING.md")
            [[ "$suffix" =~ [Cc] ]] && docs_files+=("CODE_OF_CONDUCT.md")
            [[ "$suffix" =~ [Dd] ]] && docs_files+=("SECURITY.md")
            
            if [[ "${#docs_files[@]}" -gt 0 ]]; then
                mkdir -p "$target_dir/docs"
                for f in "${docs_files[@]}"; do
                    local tpl="$DEV_CONTROL_DIR/docs-templates/$f"
                    if [[ -f "$tpl" ]]; then
                        readme_apply "$tpl" "$target_dir/docs/$f"
                    else
                        print_warning "Template not found: $f"
                    fi
                done
            fi
            continue
        fi
        
        case "$folder_type" in
            docs)
                install_docs_templates "$target_dir"
                ;;
            workflows)
                install_workflows_templates "$target_dir"
                ;;
            actions)
                install_actions_templates "$target_dir"
                ;;
            github)
                install_github_templates "$target_dir"
                ;;
            licences)
                install_licences_templates "$target_dir" "$install_all"
                ;;
            *)
                # Generic handler for other template folders
                if [[ -n "$folder_type" ]]; then
                    install_generic_templates "$target_dir" "$folder_type"
                fi
                ;;
        esac
    done
}

install_docs_templates() {
    readme_install_docs "$1"
}

install_actions_templates() {
    local target_dir="$1"
    local act_dir="$DEV_CONTROL_DIR/actions-templates"
    
    print_info "Installing composite actions to .github/actions/..."
    mkdir -p "$target_dir/.github/actions"
    
    # Each subdirectory is one action (must contain action.yml)
    for action_dir in "$act_dir"/*/; do
        if [[ -d "$action_dir" && -f "${action_dir}action.yml" ]]; then
            local action_name
            action_name=$(basename "$action_dir")
            mkdir -p "$target_dir/.github/actions/$action_name"
            
            # Process action.yml with placeholder replacement
            process_template "${action_dir}action.yml" "$target_dir/.github/actions/$action_name/action.yml"
            
            # Copy any other files in the action directory (without processing)
            for file in "$action_dir"*; do
                local filename
                filename=$(basename "$file")
                if [[ -f "$file" && "$filename" != "action.yml" ]]; then
                    cp "$file" "$target_dir/.github/actions/$action_name/$filename"
                fi
            done
        fi
    done
}

install_workflows_templates() {
    local target_dir="$1"
    local wf_dir="$DEV_CONTROL_DIR/workflows-templates"
    
    print_info "Installing workflow templates to .github/workflows/..."
    mkdir -p "$target_dir/.github/workflows"
    
    for file in "$wf_dir"/*.yml; do
        if [[ -f "$file" ]]; then
            local filename=$(basename "$file")
            # Skip init.yml and remote-init.yml (those are for manual copy)
            if [[ "$filename" != "init.yml" && "$filename" != "remote-init.yml" ]]; then
                process_template "$file" "$target_dir/.github/workflows/$filename"
            fi
        fi
    done
}

install_github_templates() {
    local target_dir="$1"
    local gh_dir="$DEV_CONTROL_DIR/github-templates"
    
    if [[ ! -d "$gh_dir" ]]; then
        print_warning "github-templates folder not found"
        return
    fi
    
    print_info "Installing GitHub templates to .github/..."
    
    mkdir -p "$target_dir/.github"
    
    # Copy ISSUE_TEMPLATE folder
    if [[ -d "$gh_dir/ISSUE_TEMPLATE" ]]; then
        mkdir -p "$target_dir/.github/ISSUE_TEMPLATE"
        for file in "$gh_dir/ISSUE_TEMPLATE"/*; do
            if [[ -f "$file" ]]; then
                local filename=$(basename "$file")
                process_template "$file" "$target_dir/.github/ISSUE_TEMPLATE/$filename"
            fi
        done
    fi
    
    # Copy PR template
    if [[ -f "$gh_dir/PULL_REQUEST_TEMPLATE.md" ]]; then
        process_template "$gh_dir/PULL_REQUEST_TEMPLATE.md" "$target_dir/.github/PULL_REQUEST_TEMPLATE.md"
    fi
    
    # Copy any other files in github-templates root
    for file in "$gh_dir"/*.md "$gh_dir"/*.yml; do
        if [[ -f "$file" ]]; then
            local filename=$(basename "$file")
            if [[ "$filename" != "PULL_REQUEST_TEMPLATE.md" ]]; then
                process_template "$file" "$target_dir/.github/$filename"
            fi
        fi
    done
}

install_licences_templates() {
    local target_dir="$1"
    local auto_choice="${2:-false}"
    local lic_dir=""
    
    # Check both folder names
    if [[ -d "$DEV_CONTROL_DIR/licence-templates" ]]; then
        lic_dir="$DEV_CONTROL_DIR/licence-templates"
    elif [[ -d "$DEV_CONTROL_DIR/licences-templates" ]]; then
        lic_dir="$DEV_CONTROL_DIR/licences-templates"
    else
        print_warning "No licence folder found (licence-templates or licences-templates)"
        return
    fi
    
    print_info "Installing licence templates..."
    
    # Show licence options
    echo ""
    echo "Select licence:"
    local idx=1
    declare -A LICENSE_FILES
    for file in "$lic_dir"/*; do
        if [[ -f "$file" ]]; then
            local fname=$(basename "$file")
            echo "  $idx) $fname"
            LICENSE_FILES[$idx]="$file"
            ((idx++))
        fi
    done
    
    # Auto-select licence when installing ALL
    if [[ "$auto_choice" == "true" ]]; then
        local pick=1
        if [[ -n "$LICENSE_TYPE" ]]; then
            for k in "${!LICENSE_FILES[@]}"; do
                local bname
                bname=$(basename "${LICENSE_FILES[$k]}")
                if [[ "${bname,,}" == "${LICENSE_TYPE,,}" ]]; then
                    pick=$k
                    break
                fi
            done
        fi
        lic_choice="$pick"
        print_info "Auto-selected licence: $(basename "${LICENSE_FILES[$lic_choice]}")" 
    else
        read -rp "Choice [1]: " lic_choice
        lic_choice="${lic_choice:-1}"
    fi
    
    local selected_licence="${LICENSE_FILES[$lic_choice]}"
    if [[ -f "$selected_licence" ]]; then
        process_template "$selected_licence" "$target_dir/LICENSE"
    else
        print_warning "No licence selected or licence file not found"
    fi
}

install_generic_templates() {
    local target_dir="$1"
    local folder_type="$2"
    local tpl_dir="$DEV_CONTROL_DIR/${folder_type}-templates"
    
    if [[ ! -d "$tpl_dir" ]]; then
        print_warning "${folder_type}-templates folder not found"
        return
    fi
    
    print_info "Installing ${folder_type} templates..."
    
    for file in "$tpl_dir"/*; do
        if [[ -f "$file" ]]; then
            local filename=$(basename "$file")
            process_template "$file" "$target_dir/$filename"
        fi
    done
}

# ============================================================================
# TARGETED FILE PROCESSING (CLI mode)
# ============================================================================

find_template_file() {
    local filename="$1"
    
    # Extract just the basename if a path was provided
    local base_filename
    base_filename=$(basename "$filename")
    
    # Search all *-templates folders for this file
    for dir in "$DEV_CONTROL_DIR"/*-templates; do
        if [[ -d "$dir" ]]; then
            local filepath="$dir/$base_filename"
            if [[ -f "$filepath" ]]; then
                echo "$filepath"
                return 0
            fi
        fi
    done
    
    return 1
}

get_target_path() {
    local template_path="$1"
    local user_path="$2"
    local target_dir
    target_dir=$(pwd)
    
    # If user provided a path (contains /), use it directly
    if [[ "$user_path" == *"/"* ]]; then
        echo "$target_dir/$user_path"
        return
    fi
    
    # Otherwise, determine destination based on source folder
    local folder_name
    folder_name=$(basename "$(dirname "$template_path")")
    
    case "$folder_name" in
        workflows-templates)
            echo "$target_dir/.github/workflows/$user_path"
            ;;
        docs-templates)
            # Default docs to repo root (user can override with path)
            echo "$target_dir/$user_path"
            ;;
        *)
            echo "$target_dir/$user_path"
            ;;
    esac
}

process_specific_files() {
    local target_dir
    target_dir=$(pwd)
    
    IFS=',' read -ra FILES <<< "$CLI_FILES"
    
    for user_path in "${FILES[@]}"; do

        user_path=$(echo "$user_path" | tr -d ' ')

        local filename
        filename=$(basename "$user_path")
        
        local template_path
        if ! template_path=$(find_template_file "$filename"); then
            print_error "Template not found: $filename"
            continue
        fi
        
        local target_path
        target_path=$(get_target_path "$template_path" "$user_path")
        
        # Check if file exists and handle overwrite
        if [[ -f "$target_path" ]] && [[ "$CLI_OVERWRITE" != "true" ]]; then
            echo -e "${YELLOW}File exists:${NC} $target_path"
            read -rp "Overwrite? [y/N]: " confirm
            if [[ ! "$confirm" =~ ^[Yy] ]]; then
                print_info "Skipped: $user_path"
                continue
            fi
        fi
        
        mkdir -p "$(dirname "$target_path")"
        
        process_template "$template_path" "$target_path"
    done
}

# ============================================================================
# COMMIT & PUSH (reusable gcda-style amend / new-commit + push)
# ============================================================================

# Stage the well-known template paths (dirs + individual files).
stage_template_paths() {
    for _p in .github/workflows .github/actions .github/ISSUE_TEMPLATE docs; do
        [[ -d "$_p" ]] && git add -A "$_p" 2>/dev/null || true
    done
    for _p in .github/PULL_REQUEST_TEMPLATE.md LICENSE LICENCE LICENSE.md LICENCE.md LICENSE.txt LICENCE.txt; do
        [[ -f "$_p" ]] && git add "$_p" 2>/dev/null || true
    done
}

# Commit staged template changes and push (gcda-style amend when prior dc-init commit exists).  Callers must stage changes and verify there is something to commit before calling this function.
#
# Usage: dc_init_commit_and_push <verb> <description> <dir_label>
#   verb        – action word for the commit message (e.g. "update", "load")
#   description – human-readable template description
#   dir_label   – directory name shown in status messages
dc_init_commit_and_push() {
    local verb="$1" description="$2" dir_label="$3"
    local current_branch
    current_branch=$(git rev-parse --abbrev-ref HEAD 2>/dev/null || echo "main")

    # Only push when the remote tracking ref already exists — avoids pushing on a
    # fresh repo where templates are loaded before the first git push.
    local _remote_branch_exists=false
    if git remote get-url origin &>/dev/null; then
        git rev-parse --verify "refs/remotes/origin/$current_branch" &>/dev/null && _remote_branch_exists=true
    fi

    local last_msg
    last_msg=$(git log -1 --format=%s 2>/dev/null || echo "")
    if [[ "$last_msg" == chore\(dc-init\):* ]]; then
        local author_date
        author_date=$(git show -s --format=%aD HEAD)
        GIT_COMMITTER_DATE="$author_date" git commit --amend --no-edit --date="$author_date" --quiet
        print_success "Amended dc-init commit for $dir_label"
        if [[ "$_remote_branch_exists" == "true" ]]; then
            if ! git push --force-with-lease origin "$current_branch" --quiet 2>/dev/null; then
                print_warning "Force-push failed for $dir_label (amended locally)"
            fi
        fi
    else
        git commit -m "chore(dc-init): ${verb} ${description}" --quiet
        print_success "Committed template ${verb} for $dir_label"
        if [[ "$_remote_branch_exists" == "true" ]]; then
            if ! git push origin "$current_branch" --quiet 2>/dev/null; then
                print_warning "Push failed for $dir_label (committed locally)"
            fi
        fi
    fi
}

# ============================================================================
# BATCH UPDATE (template-only refresh on existing repos)
# ============================================================================

run_batch_update() {
    local dirs=()

    if [[ ${#POSITIONAL_ARGS[@]} -gt 0 ]]; then
        dirs=("${POSITIONAL_ARGS[@]}")
    else
        # Recursively discover git repos (exclude .bak, .tmp, .temp, archive, build dirs)
        local find_excludes=(
            -not -path './.git'
            -not -path './.bak/*'
            -not -path './.tmp/*'
            -not -path './.temp/*'
            -not -path './.archive/*'
            -not -path '*/node_modules/*'
            -not -path '*/build/*'
            -not -path '*/_deps/*'
            -not -path '*/vendor/*'
            -not -path '*/.bak/*'
            -not -path '*/.tmp/*'
            -not -path '*/.temp/*'
            -not -path '*/.archive/*'
        )
        for _skip in "${SKIP_DIRS[@]}"; do
            _skip="${_skip%/}"  # strip trailing slash
            find_excludes+=(-not -path "./${_skip}/*" -not -path "*/${_skip}/*")
        done
        while IFS= read -r gitdir; do
            dirs+=("$(dirname "$gitdir")")
        done < <(find . -name .git "${find_excludes[@]}" | sort)
    fi

    # Filter to only directories with a remote (unless --local)
    local git_dirs=()
    for d in "${dirs[@]}"; do
        if [[ ! -d "$d/.git" ]] && [[ ! -f "$d/.git" ]]; then
            print_warning "Skipping $d (no .git found)"
            continue
        fi
        if [[ "$INCLUDE_LOCAL" != "true" ]]; then
            if ! git -C "$d" remote get-url origin &>/dev/null; then
                print_warning "Skipping $d (no remote — use --local to include)"
                continue
            fi
        fi
        git_dirs+=("$d")
    done

    if [[ ${#git_dirs[@]} -eq 0 ]]; then
        print_warning "No git repositories found to update"
        return 1
    fi

    print_info "Found ${#git_dirs[@]} repositories to update"

    # Build template folder mapping (non-interactive)
    build_template_folders

    # Read template selection: from stdin (<<< 2,3) or default to "A"
    local selection="A"
    if [[ "$DEFAULTS_ONLY" == "true" || "$ASSUME_YES" == "true" ]]; then
        if [[ ! -t 0 ]]; then
            # stdin has data (heredoc / herestring)
            read -r selection < /dev/stdin || true
            selection="${selection:-A}"
        fi
    else
        # Interactive: show menu once for the whole batch
        select_templates
        selection="${SELECTED_TEMPLATE_CHOICES:-A}"
    fi

    local choice_desc
    choice_desc=$(describe_template_choices "$selection")
    print_info "Template selection: ${selection} (${choice_desc})"

    # Load MEMBERS list from repoVars.env for owner guard
    local members_list=""
    local global_vars_file="$DEV_CONTROL_DIR/config/profiles/repoVars.env"
    if [[ -f "$global_vars_file" ]]; then
        members_list=$(grep -E '^MEMBERS=' "$global_vars_file" | head -1 | sed 's/^MEMBERS=//' | tr -d '"' || true)
    fi

    local updated=0 skipped=0

    for d in "${git_dirs[@]}"; do
        print_header
        print_info "Updating: $d"

        pushd "$d" > /dev/null || { print_error "Failed to enter $d"; continue; }

        # --- Owner guard: skip repos not owned by MEMBERS, and skip dev-control itself ---
        local remote_owner=""
        local remote_url
        remote_url=$(git config --get remote.origin.url 2>/dev/null || echo "")
        if [[ "$remote_url" =~ github\.com[:/]([^/]+)/([^/.]+) ]]; then
            remote_owner="${BASH_REMATCH[1]}"
            local remote_slug="${BASH_REMATCH[2]}"
            # Skip dev-control itself — it is the template source, not a target
            if [[ "$remote_slug" == "dev-control" ]]; then
                print_info "Skipping $d (dev-control is the template source)"
                popd > /dev/null || true
                ((skipped++)) || true
                continue
            fi
        fi
        if [[ -n "$members_list" && -n "$remote_owner" ]]; then
            local is_member=false
            IFS=',' read -ra _members <<< "$members_list"
            for m in "${_members[@]}"; do
                if [[ "$m" == "$remote_owner" ]]; then
                    is_member=true
                    break
                fi
            done
            if [[ "$is_member" == "false" ]]; then
                print_info "Skipping $d (owner '$remote_owner' not in MEMBERS)"
                popd > /dev/null || true
                ((skipped++)) || true
                continue
            fi
        fi

        # Reset variables for this repo iteration (prevent carryover)
        SHORT_DESCRIPTION=""
        LONG_DESCRIPTION=""
        LICENSE_TYPE=""
        STABILITY=""
        STABILITY_COLOR=""
        PROJECT_NAME=""
        REPO_SLUG=""
        REPO_URL=""
        ORG_NAME=""
        REPO_OWNER=""
        WEBSITE_URL=""

        # --- Recover from interrupted previous run ---
        # If template-managed files are sitting unstaged/uncommitted from a ^C'd run, commit them now
        # Stage each path individually — non-existent paths must not block others
        for _p in .github/workflows .github/actions .github/ISSUE_TEMPLATE docs; do
            [[ -d "$_p" ]] && git add -A "$_p" 2>/dev/null || true
        done
        for _p in .github/PULL_REQUEST_TEMPLATE.md LICENSE LICENCE LICENSE.md LICENCE.md LICENSE.txt LICENCE.txt; do
            [[ -f "$_p" ]] && git add "$_p" 2>/dev/null || true
        done
        if ! git diff --cached --quiet 2>/dev/null; then
            git commit -m "chore(dc-init): recover interrupted update" --quiet
            print_info "Recovered uncommitted template changes from previous run in $d"
        fi

        # --- Stash any local changes ---
        local had_stash=false
        local current_branch
        current_branch=$(git rev-parse --abbrev-ref HEAD 2>/dev/null || echo "main")

        if [[ -n "$(git status --porcelain 2>/dev/null)" ]]; then
            print_info "Stashing local changes..."
            git stash push -m "dc-init: pre-update stash" --quiet
            had_stash=true
        fi

        # --- Pull latest if remote exists ---
        if git remote get-url origin &>/dev/null; then
            print_info "Pulling latest from origin/${current_branch}..."
            if ! git pull --rebase origin "$current_branch" --quiet 2>/dev/null; then
                if [[ "$INCLUDE_LOCAL" == "true" ]]; then
                    print_warning "Pull failed (continuing anyway — --local mode)"
                else
                    print_warning "Skipping $d (pull failed — use --local to force)"
                    # Restore stash before skipping
                    if [[ "$had_stash" == "true" ]]; then
                        git stash pop --quiet 2>/dev/null || true
                    fi
                    popd > /dev/null || true
                    ((skipped++)) || true
                    continue
                fi
            fi
        fi

        # --- Load existing repo metadata from git config ---
        get_repo_info
        PROJECT_NAME="$(basename "$PWD")"
        REPO_SLUG="$(basename "$PWD")"
        if [[ -z "$ORG_NAME" ]]; then
            ORG_NAME="$(git config --local dc-init.org-name 2>/dev/null || echo "")"
        fi
        REPO_OWNER="${ORG_NAME}"
        REPO_URL="https://github.com/${ORG_NAME}/${REPO_SLUG}"
        SHORT_DESCRIPTION="${SHORT_DESCRIPTION:-$(git config --local dc-init.description 2>/dev/null || echo "")}"
        LONG_DESCRIPTION="${LONG_DESCRIPTION:-$SHORT_DESCRIPTION}"
        LICENSE_TYPE="${LICENSE_TYPE:-$(git config --local dc-init.licence-type 2>/dev/null || echo "")}"
        STABILITY="${STABILITY:-$(git config --local dc-init.stability 2>/dev/null || echo "")}"
        STABILITY_COLOR="${STABILITY_COLOR:-$(git config --local dc-init.stability-colour 2>/dev/null || echo "")}"
        CURRENT_YEAR=$(date +%Y)
        print_info "Owner: ${ORG_NAME:-unknown} | Repo: ${REPO_SLUG}"

        # --- Install templates ---
        SELECTED_TEMPLATE_CHOICES="$selection"
        install_templates "$selection"
        save_project_metadata

        # --- Commit and push template changes only ---
        stage_template_paths

        if ! git diff --cached --quiet; then
            dc_init_commit_and_push "update" "$choice_desc" "$d"
            ((updated++)) || true
        else
            print_info "No template changes needed for $d"
            ((skipped++)) || true
        fi

        # --- Restore stash ---
        if [[ "$had_stash" == "true" ]]; then
            print_info "Restoring stashed changes..."
            if ! git stash pop --quiet 2>/dev/null; then
                print_info "Auto-resolving stash conflicts in $d..."
                # Accept the stashed (local) version for any conflicted files
                git checkout --theirs -- . 2>/dev/null || true
                git add -A 2>/dev/null || true
                git stash drop --quiet 2>/dev/null || true
                print_success "Stash conflicts auto-resolved in $d"
            fi
        fi

        popd > /dev/null || true
    done

    echo ""
    print_success "Batch update complete: ${updated} updated, ${skipped} already up-to-date"
}

run_batch_init() {
    local dirs=()

    if [[ ${#POSITIONAL_ARGS[@]} -gt 0 ]]; then
        dirs=("${POSITIONAL_ARGS[@]}")
    else
        # Recursively discover git repos (exclude .bak, .tmp, .temp, archive dirs)
        local find_excludes=(
            -not -path './.git'
            -not -path './.bak/*'
            -not -path './.tmp/*'
            -not -path './.temp/*'
            -not -path './.archive/*'
            -not -path '*/node_modules/*'
            -not -path '*/.bak/*'
            -not -path '*/.tmp/*'
            -not -path '*/.temp/*'
            -not -path '*/.archive/*'
        )
        for _skip in "${SKIP_DIRS[@]}"; do
            _skip="${_skip%/}"  # strip trailing slash
            find_excludes+=(-not -path "./${_skip}/*" -not -path "*/${_skip}/*")
        done
        while IFS= read -r gitdir; do
            dirs+=("$(dirname "$gitdir")")
        done < <(find . -name .git "${find_excludes[@]}" | sort)
    fi

    # Filter out excluded directories from explicit positional args too
    if [[ ${#SKIP_DIRS[@]} -gt 0 && ${#dirs[@]} -gt 0 ]]; then
        local filtered_dirs=()
        for d in "${dirs[@]}"; do
            local excluded=false
            for _skip in "${SKIP_DIRS[@]}"; do
                _skip="${_skip%/}"
                local base
                base=$(basename "$d")
                if [[ "$base" == "$_skip" || "$d" == "$_skip" || "$d" == "./$_skip" ]]; then
                    excluded=true
                    break
                fi
            done
            if [[ "$excluded" == "false" ]]; then
                filtered_dirs+=("$d")
            else
                print_info "Excluding: $d"
            fi
        done
        dirs=("${filtered_dirs[@]}")
    fi

    if [[ ${#dirs[@]} -eq 0 ]]; then
        print_warning "No directories found to process in batch mode"
        return 1
    fi

    # Filter to only directories with a remote (unless --local)
    local filtered_remote=()
    for d in "${dirs[@]}"; do
        if [[ -d "$d/.git" ]] || [[ -f "$d/.git" ]]; then
            if [[ "$INCLUDE_LOCAL" != "true" ]]; then
                if ! git -C "$d" remote get-url origin &>/dev/null; then
                    print_warning "Skipping $d (no remote — use --local to include)"
                    continue
                fi
            fi
        fi
        filtered_remote+=("$d")
    done
    dirs=("${filtered_remote[@]}")

    if [[ ${#dirs[@]} -eq 0 ]]; then
        print_warning "No directories with remotes found to process (use --local to include local-only repos)"
        return 1
    fi

    # Ask whether to use a single repository owner for all repos (only once)
    # Default to Yes for convenience (empty input treated as Yes)
    # When --defaults is passed, auto-accept and detect owner from first repo
    if [[ "$DEFAULTS_ONLY" == "true" || "$ASSUME_YES" == "true" ]]; then
        # Auto-detect owner from the first directory's git config
        local candidate_owner=""
        if [[ -d "${dirs[0]}" ]]; then
            pushd "${dirs[0]}" > /dev/null 2>&1 || true
            if git rev-parse --git-dir > /dev/null 2>&1; then
                candidate_owner=$(git config --local dc-init.org-name 2>/dev/null || echo "")
                # Fallback: detect from remote URL
                if [[ -z "$candidate_owner" ]]; then
                    local _remote_url
                    _remote_url=$(git config --get remote.origin.url 2>/dev/null || echo "")
                    if [[ "$_remote_url" =~ github\.com[:/]([^/]+)/ ]]; then
                        candidate_owner="${BASH_REMATCH[1]}"
                    fi
                fi
            fi
            popd > /dev/null 2>&1 || true
        fi
        if [[ -n "$candidate_owner" ]]; then
            REPO_OWNER="$candidate_owner"
        fi
        ORG_NAME="$REPO_OWNER"
        REUSE_OWNER=true
        BATCH_SKIP_OWNER=false
        print_info "Using owner: ${REPO_OWNER:-auto-detect per repo} for all repositories"

        # Auto-accept reuse of initialisation config
        BATCH_REUSE_TEMPLATES=true
        print_info "Will reuse initialisation config across the batch"
    else
    read -rp "Use a single repository owner for all repos? (Y/n): " use_single_owner
    if [[ -z "${use_single_owner}" || "${use_single_owner}" =~ ^[Yy] ]]; then
        # For convenience, try to detect an owner from the first directory's local git config
        local candidate_owner=""
        if [[ -d "${dirs[0]}" ]]; then
            pushd "${dirs[0]}" > /dev/null 2>&1 || true
            # Only check local git config, don't init or fetch from GitHub
            if git rev-parse --git-dir > /dev/null 2>&1; then
                candidate_owner=$(git config --local dc-init.org-name 2>/dev/null || echo "")
            fi
            popd > /dev/null 2>&1 || true
        fi

        if [[ -n "$candidate_owner" ]]; then
            read -rp "Repository owner (user/org) [${candidate_owner}]: " shared_owner
            REPO_OWNER="${shared_owner:-$candidate_owner}"
        else
            read -rp "Repository owner (user/org): " shared_owner
            REPO_OWNER="${shared_owner:-$REPO_OWNER}"
        fi

        ORG_NAME="$REPO_OWNER"
        REUSE_OWNER=true
        BATCH_SKIP_OWNER=false
        print_info "Using owner: $REPO_OWNER for all repositories"
    else
        # Do not prefill owner prompts from detected remotes; prompt per-repo
        BATCH_SKIP_OWNER=true
        print_info "Will prompt for repository owner individually"
    fi

    # Offer to reuse initialisation config (templates, licence, stability) for all repos
    read -rp "Reuse initialisation config (templates, licence, stability) for all repositories? (y/N): " reuse_templates
    if [[ "${reuse_templates}" =~ ^[Yy] ]]; then
        BATCH_REUSE_TEMPLATES=true
        print_info "Will reuse initialisation config across the batch"
        # If --yes was passed, prefill sensible defaults for the batch
        if [[ "$ASSUME_YES" == "true" ]]; then
            BATCH_SELECTED_CHOICES="A"
            BATCH_LICENSE_TYPE="${LICENSE_TYPE:-GPL-3.0}"
            BATCH_STABILITY="${STABILITY:-stable}"
            BATCH_STABILITY_COLOR="${STABILITY_COLOR:-green}"
            print_info "Batch will run non-interactively with defaults"
        fi
    fi
    fi  # end of --defaults/--yes vs interactive

    # When --defaults is set, read template selection from stdin before the loop so that e.g. <<< 2,3 reaches template selection instead of being consumed by prompts
    if [[ "$DEFAULTS_ONLY" == "true" && "$BATCH_REUSE_TEMPLATES" == "true" && -z "$BATCH_SELECTED_CHOICES" ]]; then
        build_template_folders
        if [[ ! -t 0 ]]; then
            read -r BATCH_SELECTED_CHOICES < /dev/stdin || true
        fi
        BATCH_SELECTED_CHOICES="${BATCH_SELECTED_CHOICES:-A}"
        local choice_desc
        choice_desc=$(describe_template_choices "$BATCH_SELECTED_CHOICES")
        print_info "Template selection: ${BATCH_SELECTED_CHOICES} (${choice_desc})"
    fi

    for d in "${dirs[@]}"; do

        pushd "$d" > /dev/null || { print_error "Failed to enter $d"; continue; }

        # Ensure git repo initialised for this folder FIRST (before any config operations)
        check_git_repo

        # --- Owner guard: skip repos not owned by shared owner or MEMBERS ---
        # Run BEFORE stashing to avoid touching repos we won't process
        local remote_owner=""
        local remote_url
        remote_url=$(git config --get remote.origin.url 2>/dev/null || echo "")
        if [[ "$remote_url" =~ github\.com[:/]([^/]+)/([^/.]+) ]]; then
            remote_owner="${BASH_REMATCH[1]}"
            local remote_slug="${BASH_REMATCH[2]}"
            # Skip dev-control itself — it is the template source, not a target
            if [[ "$remote_slug" == "dev-control" ]]; then
                print_info "Skipping $d (dev-control is the template source)"
                popd > /dev/null || true
                continue
            fi
        fi
        if [[ -n "$remote_owner" ]]; then
            if [[ "$REUSE_OWNER" == "true" && -n "$REPO_OWNER" ]]; then
                # Explicit shared owner selected — strict match only
                if [[ "$remote_owner" != "$REPO_OWNER" ]]; then
                    print_info "Skipping $d (owner '$remote_owner' differs from '$REPO_OWNER')"
                    popd > /dev/null || true
                    continue
                fi
            else
                # No shared owner — fall back to MEMBERS list
                local members_list=""
                local global_vars_file="$DEV_CONTROL_DIR/config/profiles/repoVars.env"
                if [[ -f "$global_vars_file" ]]; then
                    members_list=$(grep -E '^MEMBERS=' "$global_vars_file" | head -1 | sed 's/^MEMBERS=//' | tr -d '"' || true)
                fi
                if [[ -n "$members_list" ]]; then
                    local is_member=false
                    IFS=',' read -ra _members <<< "$members_list"
                    for m in "${_members[@]}"; do
                        if [[ "$m" == "$remote_owner" ]]; then
                            is_member=true
                            break
                        fi
                    done
                    if [[ "$is_member" == "false" ]]; then
                        print_info "Skipping $d (owner '$remote_owner' not in MEMBERS)"
                        popd > /dev/null || true
                        continue
                    fi
                fi
            fi
        fi

        # --- Batch lifecycle: stash any local changes and pull latest ---
        local had_stash=false
        local current_branch
        current_branch=$(git rev-parse --abbrev-ref HEAD 2>/dev/null || echo "main")

        if [[ -n "$(git status --porcelain 2>/dev/null)" ]]; then
            print_info "Stashing local changes in $d..."
            git stash push -m "dc-init: pre-batch stash" --quiet
            had_stash=true
        fi

        # Pull latest if remote exists
        if git remote get-url origin &>/dev/null; then
            print_info "Pulling latest from origin/${current_branch}..."
            if ! git pull --rebase origin "$current_branch" --quiet 2>/dev/null; then
                print_warning "Pull failed for $d (continuing anyway)"
            fi
        fi

        # Reset variables for this repo iteration (prevent carryover from previous repos)
        # These must be reset AFTER check_git_repo but BEFORE get_repo_info
        SHORT_DESCRIPTION=""
        LONG_DESCRIPTION=""
        LICENSE_TYPE=""
        STABILITY=""
        STABILITY_COLOR=""
        PROJECT_NAME=""
        REPO_SLUG=""
        REPO_URL=""
        ORG_NAME=""
        WEBSITE_URL=""

        # Attempt to detect repo info (may set ORG_NAME if remote present)
        # This will load from THIS repo's local git config
        get_repo_info

        # Pre-fill sensible defaults based on folder name
        PROJECT_NAME="$(basename "$PWD")"
        REPO_SLUG="$(basename "$PWD")"
        if [[ -n "$REPO_OWNER" ]]; then
            ORG_NAME="$REPO_OWNER"
        fi
        REPO_URL="https://github.com/${ORG_NAME}/${REPO_SLUG}"

        if [[ "$ASSUME_YES" == "true" || "$DEFAULTS_ONLY" == "true" ]]; then
            SHORT_DESCRIPTION="${SHORT_DESCRIPTION:-A project by $ORG_NAME}"
            LONG_DESCRIPTION="${LONG_DESCRIPTION:-$SHORT_DESCRIPTION}"
            LICENSE_TYPE="${LICENSE_TYPE:-MIT}"
            STABILITY="${STABILITY:-experimental}"
            STABILITY_COLOR="${STABILITY_COLOR:-orange}"
            CURRENT_YEAR=$(date +%Y)
        else
            # Interactive collect (prefilled with defaults)
            collect_project_info
        fi

        # Handle batch reuse of initialisation config
        if [[ "$BATCH_REUSE_TEMPLATES" == "true" ]]; then
            if [[ -z "$BATCH_SELECTED_CHOICES" ]]; then
                # First repo: allow selection and capture it for reuse
                select_templates
                BATCH_SELECTED_CHOICES="${SELECTED_TEMPLATE_CHOICES:-A}"
                BATCH_LICENSE_TYPE="${LICENSE_TYPE:-$BATCH_LICENSE_TYPE}"
                BATCH_STABILITY="${STABILITY:-$BATCH_STABILITY}"
                BATCH_STABILITY_COLOR="${STABILITY_COLOR:-$BATCH_STABILITY_COLOR}"
                print_info "Captured initialisation config for reuse: ${BATCH_SELECTED_CHOICES}"
            else
                # Reuse previously captured initialisation config
                SELECTED_TEMPLATE_CHOICES="${BATCH_SELECTED_CHOICES}"
                LICENSE_TYPE="${BATCH_LICENSE_TYPE}"
                STABILITY="${BATCH_STABILITY}"
                STABILITY_COLOR="${BATCH_STABILITY_COLOR}"
                print_info "Using shared initialisation config (templates, licence, stability)"
            fi
        else
            # Not reusing batch config; allow interactive selection for this repo
            select_templates
            SELECTED_TEMPLATE_CHOICES="${SELECTED_TEMPLATE_CHOICES:-A}"
        fi

        # Default to installing ALL templates unless user set a different selection
        SELECTED_TEMPLATE_CHOICES="${SELECTED_TEMPLATE_CHOICES:-A}"
        print_info "Installing templates: ${SELECTED_TEMPLATE_CHOICES}"
        install_templates "${SELECTED_TEMPLATE_CHOICES}"

        # Save metadata for dc-create
        save_project_metadata

        # --- Batch lifecycle: commit, push, and restore stash ---
        if [[ -n "$(git status --porcelain 2>/dev/null)" ]]; then
            local choice_desc
            choice_desc=$(describe_template_choices "${SELECTED_TEMPLATE_CHOICES}")
            git add -A
            dc_init_commit_and_push "load" "$choice_desc" "$d"
        fi

        if [[ "$had_stash" == "true" ]]; then
            print_info "Restoring stashed changes in $d..."
            if ! git stash pop --quiet 2>/dev/null; then
                print_info "Auto-resolving stash conflicts in $d..."
                git checkout --theirs -- . 2>/dev/null || true
                git add -A 2>/dev/null || true
                git stash drop --quiet 2>/dev/null || true
                print_success "Stash conflicts auto-resolved in $d"
            fi
        fi

        # Show summary and auto-queue creation for batch mode (no per-repo prompts)
        local saved_batch="$BATCH_MODE"
        BATCH_MODE="true"
        show_summary
        BATCH_MODE="$saved_batch"

        if [[ "$BATCH_MODE" == "true" ]]; then
            CREATE_QUEUE+=("$PWD")
            print_info "Queued for creation: $PWD"
        fi

        popd > /dev/null || true
    done

    # After processing all folders, offer to create queued repos
    if [[ ${#CREATE_QUEUE[@]} -gt 0 ]]; then
        echo ""
        read -rp "Create queued repositories now? (y/n) [y]: " create_now
        if [[ "${create_now:-y}" =~ [Yy] ]]; then
            # Build args for create-repo.sh
            local cre_args=("--batch")
            [[ "$ASSUME_YES" == "true" ]] && cre_args+=("--yes")
            # Pass directories as relative paths
            cre_args+=("${CREATE_QUEUE[@]}")
            print_info "Launching create-repo for ${#CREATE_QUEUE[@]} repositories"
            bash "$DEV_CONTROL_DIR/scripts/create-repo.sh" "${cre_args[@]}"
        else
            print_info "Queued repositories preserved; you can run: create-repo --batch <dirs...>"
        fi
    fi
}

# ============================================================================
# SUMMARY
# ============================================================================

save_project_metadata() {
    # Store collected metadata in LOCAL git config for dc-create to retrieve
    # Only save if a local .git directory exists
    if [[ -d ".git" ]]; then
        print_info "Saving project metadata to git config..."
        git config --local dc-init.project-name "$PROJECT_NAME" 2>/dev/null || true
        git config --local dc-init.repo-slug "$REPO_SLUG" 2>/dev/null || true
        git config --local dc-init.org-name "${REPO_OWNER:-$ORG_NAME}" 2>/dev/null || true
        git config --local dc-init.repo-url "$REPO_URL" 2>/dev/null || true
        git config --local dc-init.description "$SHORT_DESCRIPTION" 2>/dev/null || true
        git config --local dc-init.long-description "$LONG_DESCRIPTION" 2>/dev/null || true
        git config --local dc-init.licence-type "$LICENSE_TYPE" 2>/dev/null || true
        git config --local dc-init.stability "$STABILITY" 2>/dev/null || true
        git config --local dc-init.stability-colour "$STABILITY_COLOR" 2>/dev/null || true
        [[ -n "$WEBSITE_URL" ]] && git config --local dc-init.website-url "$WEBSITE_URL" 2>/dev/null || true
        [[ -n "$BOT_NAME" ]] && git config --local dc-init.bot-name "$BOT_NAME" 2>/dev/null || true
        [[ -n "$BOT_EMAIL" ]] && git config --local dc-init.bot-email "$BOT_EMAIL" 2>/dev/null || true
        [[ -n "$BOT_APP_ID_SECRET" ]] && git config --local dc-init.bot-app-id-secret "$BOT_APP_ID_SECRET" 2>/dev/null || true
        [[ -n "$BOT_PRIVATE_KEY_SECRET" ]] && git config --local dc-init.bot-private-key-secret "$BOT_PRIVATE_KEY_SECRET" 2>/dev/null || true
        [[ -n "$GPG_PRIVATE_KEY_SECRET" ]] && git config --local dc-init.gpg-private-key-secret "$GPG_PRIVATE_KEY_SECRET" 2>/dev/null || true
        [[ -n "$GPG_PASSPHRASE_SECRET" ]] && git config --local dc-init.gpg-passphrase-secret "$GPG_PASSPHRASE_SECRET" 2>/dev/null || true
        [[ -n "$USER_TOKEN_SECRET" ]] && git config --local dc-init.user-token-secret "$USER_TOKEN_SECRET" 2>/dev/null || true
        [[ -n "$SECURITY_APP_ID_SECRET" ]] && git config --local dc-init.security-app-id-secret "$SECURITY_APP_ID_SECRET" 2>/dev/null || true
        [[ -n "$SECURITY_PRIVATE_KEY_SECRET" ]] && git config --local dc-init.security-private-key-secret "$SECURITY_PRIVATE_KEY_SECRET" 2>/dev/null || true
    fi
}

show_summary() {
    print_header_success "Templates Installed!"
    echo -e "${BOLD}Project:${NC} $PROJECT_NAME"
    echo -e "${BOLD}Repository:${NC} $REPO_URL"
    echo ""
    echo -e "${BOLD}Next steps:${NC}"
    echo -e "  1. Review and customise the generated files"
    echo -e "  2. Replace placeholder sections - if any remain (marked with {{}})"
    echo ""
    
    # Offer to create GitHub repository
    echo -e "${BOLD}Create GitHub Repository?${NC}"
    echo "dc-init can now launch create-repo to set up your GitHub repository"
    echo "with the configuration we just collected."
    echo ""

    local show_repo_instructions=false
    if [[ "$BATCH_MODE" == "true" ]]; then
        print_info "Batch mode: skipping create-repo prompt for $PROJECT_NAME"
        show_repo_instructions=true
    else
        read -rp "Launch create-repo now? (y/n) [y]: " launch_create_repo
        if [[ "${launch_create_repo:-y}" =~ [Yy] ]]; then
            echo ""
            print_info "Launching create-repo..."
            echo ""
            # Find and run create-repo script
            if [[ -f "$DEV_CONTROL_DIR/scripts/create-repo.sh" ]]; then
                bash "$DEV_CONTROL_DIR/scripts/create-repo.sh"
            else
                print_warning "create-repo.sh not found at $DEV_CONTROL_DIR/scripts/create-repo.sh"
                show_repo_instructions=true
            fi
        else
            show_repo_instructions=true
        fi
    fi

    if [[ "$show_repo_instructions" == "true" ]]; then
        echo -e "  3. Create repository: ${CYAN}dc-create${NC}"
        echo -e "  or"
        echo -e "  4. Create manually: ${CYAN}git init && git add . && git commit -m 'Add documentation'${NC}"
    fi
    echo ""
}

# ============================================================================
# MAIN EXECUTION
# ============================================================================

main() {
    parse_args "$@"
    
    if [[ "$CLI_HELP" == "true" ]]; then
        show_help
        exit 0
    fi
    
    print_header "Dev-Control Template Loader"
    
    # Initialise git repo if needed and get user info early
    get_git_user_info

    # Resolve default branch name: CLI flag > git global config > "main"
    if [[ -z "$DEFAULT_BRANCH" ]]; then
        DEFAULT_BRANCH=$(git config --global init.defaultBranch 2>/dev/null || echo "main")
        DEFAULT_BRANCH="${DEFAULT_BRANCH:-main}"
    fi

    # In single-repo mode (not batch), prompt for branch name if interactive
    if [[ "$BATCH_MODE" != "true" && "$DEFAULTS_ONLY" != "true" ]]; then
        local detected_branch=""
        if [[ -d ".git" ]]; then
            detected_branch=$(git symbolic-ref --short HEAD 2>/dev/null || echo "")
        fi
        local branch_hint="$DEFAULT_BRANCH"
        if [[ -n "$detected_branch" && "$detected_branch" != "$DEFAULT_BRANCH" ]]; then
            branch_hint="$detected_branch"
            print_warning "Detected branch: $detected_branch (git global default: $DEFAULT_BRANCH)"
        fi
        read -rp "Default branch name [$branch_hint]: " branch_input
        DEFAULT_BRANCH="${branch_input:-$branch_hint}"
    fi

    check_git_repo
    
    local template_folders
    template_folders=$(discover_template_folders)
    
    if [[ -z "$template_folders" ]]; then
        print_error "No *-templates folders found in: $DEV_CONTROL_DIR"
        exit 1
    fi
    
    # CLI mode: process specific files
    if [[ -n "$CLI_FILES" ]]; then
        print_info "CLI mode: Processing specific files"
        print_info "Files: $CLI_FILES"
        print_info "Overwrite: $CLI_OVERWRITE"
        echo ""
        
        get_repo_info
        
        # Collect project info (or use defaults for quick mode)
        if [[ "$CLI_OVERWRITE" == "true" || "$DEFAULTS_ONLY" == "true" ]]; then
            # Quick mode - use defaults from git
            PROJECT_NAME="${PROJECT_NAME:-$(basename "$(pwd)")}"
            SHORT_DESCRIPTION="${SHORT_DESCRIPTION:-A project by $ORG_NAME}"
            LONG_DESCRIPTION="${LONG_DESCRIPTION:-$SHORT_DESCRIPTION}"
            LICENSE_TYPE="${LICENSE_TYPE:-MIT}"
            STABILITY="${STABILITY:-experimental}"
            STABILITY_COLOR="${STABILITY_COLOR:-orange}"
            CURRENT_YEAR=$(date +%Y)
            
            print_info "Using detected values:"
            echo "  Project: $PROJECT_NAME"
            echo "  Org: $ORG_NAME"
            echo "  URL: $REPO_URL"
            echo ""
        else
            collect_project_info
        fi
        
        process_specific_files
        
        echo ""
        print_success "Done!"
        exit 0
    fi

    if [[ "$BATCH_MODE" == "true" ]]; then
        if [[ "$UPDATE_ONLY" == "true" ]]; then
            print_info "Batch update mode enabled"
            run_batch_update
        else
            print_info "Batch mode enabled"
            run_batch_init
        fi
        exit 0
    fi

    print_info "Dev-Control directory: $DEV_CONTROL_DIR"
    print_info "Working directory: $(pwd)"
    print_info "Available template folders:"
    for dir in $template_folders; do
        echo "  • $(basename "$dir")"
    done
    
    if ! git rev-parse --git-dir > /dev/null 2>&1; then
        print_warning "Not a git repository - some features may not work."
        echo ""
    fi
    
    get_repo_info
    if [[ "$DEFAULTS_ONLY" == "true" ]]; then
        PROJECT_NAME="${PROJECT_NAME:-$(basename "$(pwd)")}" 
        REPO_SLUG="${REPO_SLUG:-$PROJECT_NAME}"
        REPO_OWNER="${REPO_OWNER:-$ORG_NAME}"
        ORG_NAME="${ORG_NAME:-$REPO_OWNER}"
        if [[ -n "$ORG_NAME" && -z "$REPO_URL" ]]; then
            REPO_URL="https://github.com/${ORG_NAME}/${REPO_SLUG}"
        fi
        SHORT_DESCRIPTION="${SHORT_DESCRIPTION:-A project by $ORG_NAME}"
        LONG_DESCRIPTION="${LONG_DESCRIPTION:-$SHORT_DESCRIPTION}"
        LICENSE_TYPE="${LICENSE_TYPE:-MIT}"
        STABILITY="${STABILITY:-experimental}"
        STABILITY_COLOR="${STABILITY_COLOR:-orange}"
        CURRENT_YEAR=$(date +%Y)
        print_info "Using cached/default values (template selection still required)"
    else
        collect_project_info
    fi
    
    # Call select_templates directly (avoids subshell)
    select_templates
    local selection="${SELECTED_TEMPLATE_CHOICES:-}"
    
    echo ""
    print_info "Installing templates..."
    install_templates "$selection"

    # Save metadata for dc-create to use
    save_project_metadata

    # Commit and push installed templates when in a tracked git repo.
    # Stash any dirty working-tree changes first so staging is clean, then pop after the commit.
    if git rev-parse --git-dir > /dev/null 2>&1; then
        local _stashed=false
        if [[ -n "$(git status --porcelain 2>/dev/null | grep -v '^\?\?')" ]]; then
            print_info "Stashing local changes before template commit (will restore after)..."
            git stash push -m "dc-init: pre-template-load stash" --quiet 2>/dev/null && _stashed=true
        fi

        stage_template_paths
        if ! git diff --cached --quiet; then
            local choice_desc
            choice_desc=$(describe_template_choices "$selection")
            dc_init_commit_and_push "load" "$choice_desc" "$(basename "$PWD")"
        else
            print_info "No template changes to commit"
        fi

        if [[ "$_stashed" == "true" ]]; then
            print_info "Restoring stashed changes..."
            git stash pop --quiet 2>/dev/null || print_warning "Stash pop failed — run 'git stash pop' manually"
        fi
    fi

    show_summary
}

main "$@"