diff --git a/misc/create_lxc.sh b/misc/create_lxc.sh
index ea53362e..4426ff07 100644
--- a/misc/create_lxc.sh
+++ b/misc/create_lxc.sh
@@ -1,37 +1,42 @@
 #!/usr/bin/env bash
-
 # Copyright (c) 2021-2025 tteck
 # Author: tteck (tteckster)
 # Co-Author: MickLesk
 # License: MIT | https://github.com/community-scripts/ProxmoxVE/raw/main/LICENSE
 
-# This sets verbose mode if the global variable is set to "yes"
-if [ "$CREATE_LXC_VERBOSE" == "yes" ]; then set -x; fi
+# ------------------------------------------------------------------------------
+# Optional verbose mode (debug tracing)
+# ------------------------------------------------------------------------------
+if [[ "${CREATE_LXC_VERBOSE:-no}" == "yes" ]]; then set -x; fi
 
+# ------------------------------------------------------------------------------
+# Load core functions (msg_info/msg_ok/msg_error/…)
+# ------------------------------------------------------------------------------
 if command -v curl >/dev/null 2>&1; then
+  # Achtung: bewusst exakt diese URL-Struktur
   source <(curl -fsSL https://git.community-scripts.org/community-scripts/ProxmoxVED/raw/branch/main/misc/core.func)
   load_functions
-  #echo "(create-lxc.sh) Loaded core.func via curl"
 elif command -v wget >/dev/null 2>&1; then
   source <(wget -qO- https://git.community-scripts.org/community-scripts/ProxmoxVED/raw/branch/main/misc/core.func)
   load_functions
-  #echo "(create-lxc.sh) Loaded core.func via wget"
 fi
 
-# This sets error handling options and defines the error_handler function to handle errors
+# ------------------------------------------------------------------------------
+# Strict error handling
+# ------------------------------------------------------------------------------
 set -Eeuo pipefail
 trap 'error_handler $LINENO "$BASH_COMMAND"' ERR
 trap on_exit EXIT
 trap on_interrupt INT
 trap on_terminate TERM
 
-function on_exit() {
+on_exit() {
   local exit_code="$?"
   [[ -n "${lockfile:-}" && -e "$lockfile" ]] && rm -f "$lockfile"
   exit "$exit_code"
 }
 
-function error_handler() {
+error_handler() {
   local exit_code="$?"
   local line_number="$1"
   local command="$2"
@@ -40,17 +45,15 @@ function error_handler() {
   exit "$exit_code"
 }
 
-function on_interrupt() {
+on_interrupt() {
   echo -e "\n${RD}Interrupted by user (SIGINT)${CL}"
   exit 130
 }
-
-function on_terminate() {
+on_terminate() {
   echo -e "\n${RD}Terminated by signal (SIGTERM)${CL}"
   exit 143
 }
-
-function exit_script() {
+exit_script() {
   clear
   printf "\e[?25h"
   echo -e "\n${CROSS}${RD}User exited script${CL}\n"
@@ -58,39 +61,100 @@ function exit_script() {
   exit 1
 }
 
-# Resolve and validate a preselected storage for a given class.
-# class: "template" -> requires content=vztmpl
-#        "container" -> requires content=rootdir
+# ------------------------------------------------------------------------------
+# Helpers (dynamic versioning / template parsing)
+# ------------------------------------------------------------------------------
+pkg_ver() { dpkg-query -W -f='${Version}\n' "$1" 2>/dev/null || echo ""; }
+pkg_cand() { apt-cache policy "$1" 2>/dev/null | awk '/Candidate:/ {print $2}'; }
+
+ver_ge() { dpkg --compare-versions "$1" ge "$2"; }
+ver_gt() { dpkg --compare-versions "$1" gt "$2"; }
+ver_lt() { dpkg --compare-versions "$1" lt "$2"; }
+
+# Extract Debian OS minor from template name: debian-13-standard_13.1-1_amd64.tar.zst => "13.1"
+parse_template_osver() { sed -n 's/.*_\([0-9][0-9]*\(\.[0-9]\+\)\?\)-.*/\1/p' <<<"$1"; }
+
+# Offer upgrade for pve-container/lxc-pve if candidate > installed; optional auto-retry pct create
+# Returns:
+#   0 = no upgrade needed
+#   1 = upgraded (and if do_retry=yes and retry succeeded, creation done)
+#   2 = user declined
+#   3 = upgrade attempted but failed OR retry failed
+offer_lxc_stack_upgrade_and_maybe_retry() {
+  local do_retry="${1:-no}" # yes|no
+  local _pvec_i _pvec_c _lxcp_i _lxcp_c need=0
+
+  _pvec_i="$(pkg_ver pve-container)"
+  _lxcp_i="$(pkg_ver lxc-pve)"
+  _pvec_c="$(pkg_cand pve-container)"
+  _lxcp_c="$(pkg_cand lxc-pve)"
+
+  if [[ -n "$_pvec_c" && "$_pvec_c" != "none" ]]; then
+    ver_gt "$_pvec_c" "${_pvec_i:-0}" && need=1
+  fi
+  if [[ -n "$_lxcp_c" && "$_lxcp_c" != "none" ]]; then
+    ver_gt "$_lxcp_c" "${_lxcp_i:-0}" && need=1
+  fi
+  if [[ $need -eq 0 ]]; then
+    msg_debug "No newer candidate for pve-container/lxc-pve (installed=$_pvec_i/$_lxcp_i, cand=$_pvec_c/$_lxcp_c)"
+    return 0
+  fi
+
+  echo
+  echo "An update for the Proxmox LXC stack is available:"
+  echo "  pve-container: installed=${_pvec_i:-n/a}  candidate=${_pvec_c:-n/a}"
+  echo "  lxc-pve     : installed=${_lxcp_i:-n/a}  candidate=${_lxcp_c:-n/a}"
+  echo
+  read -rp "Do you want to upgrade now? [y/N] " _ans
+  case "${_ans,,}" in
+  y | yes)
+    msg_info "Upgrading Proxmox LXC stack (pve-container, lxc-pve)"
+    if apt-get update -qq && apt-get install -y --only-upgrade pve-container lxc-pve; then
+      msg_ok "LXC stack upgraded."
+      if [[ "$do_retry" == "yes" ]]; then
+        msg_info "Retrying container creation after upgrade"
+        if pct create "$CTID" "${TEMPLATE_STORAGE}:vztmpl/${TEMPLATE}" "${PCT_OPTIONS[@]}" >>"$LOGFILE" 2>&1; then
+          msg_ok "Container created successfully after upgrade."
+          return 1
+        else
+          msg_error "pct create still failed after upgrade. See $LOGFILE"
+          return 3
+        fi
+      fi
+      return 1
+    else
+      msg_error "Upgrade failed. Please check APT output."
+      return 3
+    fi
+    ;;
+  *) return 2 ;;
+  esac
+}
+
+# ------------------------------------------------------------------------------
+# Storage discovery / selection helpers
+# ------------------------------------------------------------------------------
 resolve_storage_preselect() {
-  local class="$1"
-  local preselect="$2"
-  local required_content=""
+  local class="$1" preselect="$2" required_content=""
   case "$class" in
   template) required_content="vztmpl" ;;
   container) required_content="rootdir" ;;
   *) return 1 ;;
   esac
-
-  # No preselect provided
-  [ -z "$preselect" ] && return 1
-
-  # Check storage exists and supports required content
+  [[ -z "$preselect" ]] && return 1
   if ! pvesm status -content "$required_content" | awk 'NR>1{print $1}' | grep -qx -- "$preselect"; then
     msg_warn "Preselected storage '${preselect}' does not support content '${required_content}' (or not found)"
     return 1
   fi
 
-  # Build human-readable info string from pvesm status
-  # Expected columns: Name Type Status Total Used Free ...
   local line total used free
   line="$(pvesm status | awk -v s="$preselect" 'NR>1 && $1==s {print $0}')"
-  if [ -z "$line" ]; then
+  if [[ -z "$line" ]]; then
     STORAGE_INFO="n/a"
   else
-    total="$(echo "$line" | awk '{print $4}')"
-    used="$(echo "$line" | awk '{print $5}')"
-    free="$(echo "$line" | awk '{print $6}')"
-    # Format bytes to IEC
+    total="$(awk '{print $4}' <<<"$line")"
+    used="$(awk '{print $5}' <<<"$line")"
+    free="$(awk '{print $6}' <<<"$line")"
     local total_h used_h free_h
     if command -v numfmt >/dev/null 2>&1; then
       total_h="$(numfmt --to=iec --suffix=B --format %.1f "$total" 2>/dev/null || echo "$total")"
@@ -101,30 +165,22 @@ resolve_storage_preselect() {
       STORAGE_INFO="Free: ${free}  Used: ${used}"
     fi
   fi
-
-  # Set outputs expected by your callers
   STORAGE_RESULT="$preselect"
   return 0
 }
 
-function check_storage_support() {
-  local CONTENT="$1"
-  local -a VALID_STORAGES=()
-
+check_storage_support() {
+  local CONTENT="$1" VALID=0
   while IFS= read -r line; do
     local STORAGE_NAME
     STORAGE_NAME=$(awk '{print $1}' <<<"$line")
-    [[ -z "$STORAGE_NAME" ]] && continue
-    VALID_STORAGES+=("$STORAGE_NAME")
+    [[ -n "$STORAGE_NAME" ]] && VALID=1
   done < <(pvesm status -content "$CONTENT" 2>/dev/null | awk 'NR>1')
-
-  [[ ${#VALID_STORAGES[@]} -gt 0 ]]
+  [[ $VALID -eq 1 ]]
 }
 
-# This function selects a storage pool for a given content type (e.g., rootdir, vztmpl).
-function select_storage() {
+select_storage() {
   local CLASS=$1 CONTENT CONTENT_LABEL
-
   case $CLASS in
   container)
     CONTENT='rootdir'
@@ -156,8 +212,7 @@ function select_storage() {
     ;;
   esac
 
-  # Check for preset STORAGE variable
-  if [ "$CONTENT" = "rootdir" ] && [ -n "${STORAGE:-}" ]; then
+  if [[ "$CONTENT" == "rootdir" && -n "${STORAGE:-}" ]]; then
     if pvesm status -content "$CONTENT" | awk 'NR>1 {print $1}' | grep -qx "$STORAGE"; then
       STORAGE_RESULT="$STORAGE"
       msg_info "Using preset storage: $STORAGE_RESULT for $CONTENT_LABEL"
@@ -168,28 +223,27 @@ function select_storage() {
     fi
   fi
 
-  local -A STORAGE_MAP
-  local -a MENU
+  declare -A STORAGE_MAP
+  local -a MENU=()
   local COL_WIDTH=0
 
   while read -r TAG TYPE _ TOTAL USED FREE _; do
     [[ -n "$TAG" && -n "$TYPE" ]] || continue
-    local STORAGE_NAME="$TAG"
-    local DISPLAY="${STORAGE_NAME} (${TYPE})"
+    local DISPLAY="${TAG} (${TYPE})"
     local USED_FMT=$(numfmt --to=iec --from-unit=K --format %.1f <<<"$USED")
     local FREE_FMT=$(numfmt --to=iec --from-unit=K --format %.1f <<<"$FREE")
     local INFO="Free: ${FREE_FMT}B  Used: ${USED_FMT}B"
-    STORAGE_MAP["$DISPLAY"]="$STORAGE_NAME"
+    STORAGE_MAP["$DISPLAY"]="$TAG"
     MENU+=("$DISPLAY" "$INFO" "OFF")
     ((${#DISPLAY} > COL_WIDTH)) && COL_WIDTH=${#DISPLAY}
   done < <(pvesm status -content "$CONTENT" | awk 'NR>1')
 
-  if [ ${#MENU[@]} -eq 0 ]; then
+  if [[ ${#MENU[@]} -eq 0 ]]; then
     msg_error "No storage found for content type '$CONTENT'."
     return 2
   fi
 
-  if [ $((${#MENU[@]} / 3)) -eq 1 ]; then
+  if [[ $((${#MENU[@]} / 3)) -eq 1 ]]; then
     STORAGE_RESULT="${STORAGE_MAP[${MENU[0]}]}"
     STORAGE_INFO="${MENU[1]}"
     return 0
@@ -201,19 +255,13 @@ function select_storage() {
     DISPLAY_SELECTED=$(whiptail --backtitle "Proxmox VE Helper Scripts" \
       --title "Storage Pools" \
       --radiolist "Which storage pool for ${CONTENT_LABEL,,}?\n(Spacebar to select)" \
-      16 "$WIDTH" 6 "${MENU[@]}" 3>&1 1>&2 2>&3)
+      16 "$WIDTH" 6 "${MENU[@]}" 3>&1 1>&2 2>&3) || exit_script
 
-    # Cancel or ESC
-    [[ $? -ne 0 ]] && exit_script
-
-    # Strip trailing whitespace or newline (important for storages like "storage (dir)")
     DISPLAY_SELECTED=$(sed 's/[[:space:]]*$//' <<<"$DISPLAY_SELECTED")
-
     if [[ -z "$DISPLAY_SELECTED" || -z "${STORAGE_MAP[$DISPLAY_SELECTED]+_}" ]]; then
       whiptail --msgbox "No valid storage selected. Please try again." 8 58
       continue
     fi
-
     STORAGE_RESULT="${STORAGE_MAP[$DISPLAY_SELECTED]}"
     for ((i = 0; i < ${#MENU[@]}; i += 3)); do
       if [[ "${MENU[$i]}" == "$DISPLAY_SELECTED" ]]; then
@@ -225,7 +273,9 @@ function select_storage() {
   done
 }
 
-# Test if required variables are set
+# ------------------------------------------------------------------------------
+# Required input variables
+# ------------------------------------------------------------------------------
 [[ "${CTID:-}" ]] || {
   msg_error "You need to set 'CTID' variable."
   exit 203
@@ -239,13 +289,11 @@ msg_debug "CTID=$CTID"
 msg_debug "PCT_OSTYPE=$PCT_OSTYPE"
 msg_debug "PCT_OSVERSION=${PCT_OSVERSION:-default}"
 
-# Test if ID is valid
-[ "$CTID" -ge "100" ] || {
+# ID checks
+[[ "$CTID" -ge 100 ]] || {
   msg_error "ID cannot be less than 100."
   exit 205
 }
-
-# Test if ID is in use
 if qm status "$CTID" &>/dev/null || pct status "$CTID" &>/dev/null; then
   echo -e "ID '$CTID' is already in use."
   unset CTID
@@ -253,18 +301,18 @@ if qm status "$CTID" &>/dev/null || pct status "$CTID" &>/dev/null; then
   exit 206
 fi
 
-# This checks for the presence of valid Container Storage and Template Storage locations
-if ! check_storage_support "rootdir"; then
+# Storage capability check
+check_storage_support "rootdir" || {
   msg_error "No valid storage found for 'rootdir' [Container]"
   exit 1
-fi
-if ! check_storage_support "vztmpl"; then
+}
+check_storage_support "vztmpl" || {
   msg_error "No valid storage found for 'vztmpl' [Template]"
   exit 1
-fi
+}
 
 # Template storage selection
-if resolve_storage_preselect template "${TEMPLATE_STORAGE}"; then
+if resolve_storage_preselect template "${TEMPLATE_STORAGE:-}"; then
   TEMPLATE_STORAGE="$STORAGE_RESULT"
   TEMPLATE_STORAGE_INFO="$STORAGE_INFO"
   msg_ok "Storage ${BL}${TEMPLATE_STORAGE}${CL} (${TEMPLATE_STORAGE_INFO}) [Template]"
@@ -280,7 +328,7 @@ else
 fi
 
 # Container storage selection
-if resolve_storage_preselect container "${CONTAINER_STORAGE}"; then
+if resolve_storage_preselect container "${CONTAINER_STORAGE:-}"; then
   CONTAINER_STORAGE="$STORAGE_RESULT"
   CONTAINER_STORAGE_INFO="$STORAGE_INFO"
   msg_ok "Storage ${BL}${CONTAINER_STORAGE}${CL} (${CONTAINER_STORAGE_INFO}) [Container]"
@@ -295,41 +343,35 @@ else
   done
 fi
 
-# Storage Content Validation
+# Validate content types
 msg_info "Validating content types of storage '$CONTAINER_STORAGE'"
 STORAGE_CONTENT=$(grep -A4 -E "^(zfspool|dir|lvmthin|lvm): $CONTAINER_STORAGE" /etc/pve/storage.cfg | grep content | awk '{$1=""; print $0}' | xargs)
-
 msg_debug "Storage '$CONTAINER_STORAGE' has content types: $STORAGE_CONTENT"
-
-# check if rootdir supported
-if ! grep -qw "rootdir" <<<"$STORAGE_CONTENT"; then
+grep -qw "rootdir" <<<"$STORAGE_CONTENT" || {
   msg_error "Storage '$CONTAINER_STORAGE' does not support 'rootdir'. Cannot create LXC."
   exit 217
-fi
+}
 msg_ok "Storage '$CONTAINER_STORAGE' supports 'rootdir'"
 
-# check if template storage is compatible
 msg_info "Validating content types of template storage '$TEMPLATE_STORAGE'"
 TEMPLATE_CONTENT=$(grep -A4 -E "^[^:]+: $TEMPLATE_STORAGE" /etc/pve/storage.cfg | grep content | awk '{$1=""; print $0}' | xargs)
-
 msg_debug "Template storage '$TEMPLATE_STORAGE' has content types: $TEMPLATE_CONTENT"
-
 if ! grep -qw "vztmpl" <<<"$TEMPLATE_CONTENT"; then
   msg_warn "Template storage '$TEMPLATE_STORAGE' does not declare 'vztmpl'. This may cause pct create to fail."
 else
   msg_ok "Template storage '$TEMPLATE_STORAGE' supports 'vztmpl'"
 fi
 
-# Check free space on selected container storage
+# Free space check
 STORAGE_FREE=$(pvesm status | awk -v s="$CONTAINER_STORAGE" '$1 == s { print $6 }')
 REQUIRED_KB=$((${PCT_DISK_SIZE:-8} * 1024 * 1024))
-if [ "$STORAGE_FREE" -lt "$REQUIRED_KB" ]; then
+[[ "$STORAGE_FREE" -ge "$REQUIRED_KB" ]] || {
   msg_error "Not enough space on '$CONTAINER_STORAGE'. Needed: ${PCT_DISK_SIZE:-8}G."
   exit 214
-fi
+}
 
-# Check Cluster Quorum if in Cluster
-if [ -f /etc/pve/corosync.conf ]; then
+# Cluster quorum (if cluster)
+if [[ -f /etc/pve/corosync.conf ]]; then
   msg_info "Checking cluster quorum"
   if ! pvecm status | awk -F':' '/^Quorate/ { exit ($2 ~ /Yes/) ? 0 : 1 }'; then
     msg_error "Cluster is not quorate. Start all nodes or configure quorum device (QDevice)."
@@ -338,7 +380,9 @@ if [ -f /etc/pve/corosync.conf ]; then
   msg_ok "Cluster is quorate"
 fi
 
-# Update LXC template list
+# ------------------------------------------------------------------------------
+# Template discovery & validation
+# ------------------------------------------------------------------------------
 TEMPLATE_SEARCH="${PCT_OSTYPE}-${PCT_OSVERSION:-}"
 case "$PCT_OSTYPE" in
 debian | ubuntu) TEMPLATE_PATTERN="-standard_" ;;
@@ -348,28 +392,22 @@ esac
 
 msg_info "Searching for template '$TEMPLATE_SEARCH'"
 
-# 1. get / check local templates
 mapfile -t LOCAL_TEMPLATES < <(
   pveam list "$TEMPLATE_STORAGE" 2>/dev/null |
     awk -v s="$TEMPLATE_SEARCH" -v p="$TEMPLATE_PATTERN" '$1 ~ s && $1 ~ p {print $1}' |
-    sed 's/.*\///' | sort -t - -k 2 -V
+    sed 's|.*/||' | sort -t - -k 2 -V
 )
 
-# 2. get online templates
 pveam update >/dev/null 2>&1 || msg_warn "Could not update template catalog (pveam update failed)."
 mapfile -t ONLINE_TEMPLATES < <(
   pveam available -section system 2>/dev/null |
     sed -n "s/.*\($TEMPLATE_SEARCH.*$TEMPLATE_PATTERN.*\)/\1/p" |
     sort -t - -k 2 -V
 )
-if [ ${#ONLINE_TEMPLATES[@]} -gt 0 ]; then
-  ONLINE_TEMPLATE="${ONLINE_TEMPLATES[-1]}"
-else
-  ONLINE_TEMPLATE=""
-fi
+ONLINE_TEMPLATE=""
+[[ ${#ONLINE_TEMPLATES[@]} -gt 0 ]] && ONLINE_TEMPLATE="${ONLINE_TEMPLATES[-1]}"
 
-# 3. Local vs Online
-if [ ${#LOCAL_TEMPLATES[@]} -gt 0 ]; then
+if [[ ${#LOCAL_TEMPLATES[@]} -gt 0 ]]; then
   TEMPLATE="${LOCAL_TEMPLATES[-1]}"
   TEMPLATE_SOURCE="local"
 else
@@ -377,24 +415,19 @@ else
   TEMPLATE_SOURCE="online"
 fi
 
-# 4. Getting Path (universal, also for nfs/cifs)
 TEMPLATE_PATH="$(pvesm path $TEMPLATE_STORAGE:vztmpl/$TEMPLATE 2>/dev/null || true)"
 if [[ -z "$TEMPLATE_PATH" ]]; then
   TEMPLATE_BASE=$(awk -v s="$TEMPLATE_STORAGE" '$1==s {f=1} f && /path/ {print $2; exit}' /etc/pve/storage.cfg)
-  if [[ -n "$TEMPLATE_BASE" ]]; then
-    TEMPLATE_PATH="$TEMPLATE_BASE/template/cache/$TEMPLATE"
-  fi
+  [[ -n "$TEMPLATE_BASE" ]] && TEMPLATE_PATH="$TEMPLATE_BASE/template/cache/$TEMPLATE"
 fi
-
-if [[ -z "$TEMPLATE_PATH" ]]; then
+[[ -n "$TEMPLATE_PATH" ]] || {
   msg_error "Unable to resolve template path for $TEMPLATE_STORAGE. Check storage type and permissions."
   exit 220
-fi
+}
 
 msg_ok "Template ${BL}$TEMPLATE${CL} [$TEMPLATE_SOURCE]"
 msg_debug "Resolved TEMPLATE_PATH=$TEMPLATE_PATH"
 
-# 5. Validation
 NEED_DOWNLOAD=0
 if [[ ! -f "$TEMPLATE_PATH" ]]; then
   msg_info "Template not present locally – will download."
@@ -420,7 +453,6 @@ else
   msg_ok "Template $TEMPLATE is present and valid."
 fi
 
-# 6. Update-Check (if local exist)
 if [[ "$TEMPLATE_SOURCE" == "local" && -n "$ONLINE_TEMPLATE" && "$TEMPLATE" != "$ONLINE_TEMPLATE" ]]; then
   msg_warn "Local template is outdated: $TEMPLATE (latest available: $ONLINE_TEMPLATE)"
   if whiptail --yesno "A newer template is available:\n$ONLINE_TEMPLATE\n\nDo you want to download and use it instead?" 12 70; then
@@ -431,7 +463,6 @@ if [[ "$TEMPLATE_SOURCE" == "local" && -n "$ONLINE_TEMPLATE" && "$TEMPLATE" != "
   fi
 fi
 
-# 7. Download if needed
 if [[ "$NEED_DOWNLOAD" -eq 1 ]]; then
   [[ -f "$TEMPLATE_PATH" ]] && rm -f "$TEMPLATE_PATH"
   for attempt in {1..3}; do
@@ -440,7 +471,7 @@ if [[ "$NEED_DOWNLOAD" -eq 1 ]]; then
       msg_ok "Template download successful."
       break
     fi
-    if [ $attempt -eq 3 ]; then
+    if [[ $attempt -eq 3 ]]; then
       msg_error "Failed after 3 attempts. Please check network access, permissions, or manually run:\n  pveam download $TEMPLATE_STORAGE $TEMPLATE"
       exit 222
     fi
@@ -448,7 +479,6 @@ if [[ "$NEED_DOWNLOAD" -eq 1 ]]; then
   done
 fi
 
-# 8. Final Check – Template usability
 if ! pveam list "$TEMPLATE_STORAGE" 2>/dev/null | grep -q "$TEMPLATE"; then
   msg_error "Template $TEMPLATE not available in storage $TEMPLATE_STORAGE after download."
   exit 223
@@ -456,9 +486,19 @@ fi
 msg_ok "Template $TEMPLATE is ready for container creation."
 
 # ------------------------------------------------------------------------------
-# Create LXC Container with validation, recovery and debug option
+# Dynamic preflight for Debian 13.x: offer upgrade if available (no hard mins)
 # ------------------------------------------------------------------------------
+if [[ "$PCT_OSTYPE" == "debian" ]]; then
+  OSVER="$(parse_template_osver "$TEMPLATE")"
+  if [[ -n "$OSVER" ]]; then
+    # Proactive, aber ohne Abbruch – nur Angebot
+    offer_lxc_stack_upgrade_and_maybe_retry "no" || true
+  fi
+fi
 
+# ------------------------------------------------------------------------------
+# Create LXC Container
+# ------------------------------------------------------------------------------
 msg_info "Creating LXC container"
 
 # Ensure subuid/subgid entries exist
@@ -469,7 +509,7 @@ grep -q "root:100000:65536" /etc/subgid || echo "root:100000:65536" >>/etc/subgi
 PCT_OPTIONS=(${PCT_OPTIONS[@]:-${DEFAULT_PCT_OPTIONS[@]}})
 [[ " ${PCT_OPTIONS[*]} " =~ " -rootfs " ]] || PCT_OPTIONS+=(-rootfs "$CONTAINER_STORAGE:${PCT_DISK_SIZE:-8}")
 
-# Secure with lockfile
+# Lock by template file (avoid concurrent downloads/creates)
 lockfile="/tmp/template.${TEMPLATE}.lock"
 exec 9>"$lockfile" || {
   msg_error "Failed to create lock file '$lockfile'."
@@ -509,15 +549,58 @@ if ! pct create "$CTID" "${TEMPLATE_STORAGE}:vztmpl/${TEMPLATE}" "${PCT_OPTIONS[
     if [[ "$TEMPLATE_STORAGE" != "local" ]]; then
       msg_warn "Retrying container creation with fallback to local storage..."
       LOCAL_TEMPLATE_PATH="/var/lib/vz/template/cache/$TEMPLATE"
-      if [ ! -f "$LOCAL_TEMPLATE_PATH" ]; then
+      if [[ ! -f "$LOCAL_TEMPLATE_PATH" ]]; then
         msg_info "Downloading template to local..."
         pveam download local "$TEMPLATE" >/dev/null 2>&1
       fi
       if pct create "$CTID" "local:vztmpl/${TEMPLATE}" "${PCT_OPTIONS[@]}" >>"$LOGFILE" 2>&1; then
         msg_ok "Container successfully created using local fallback."
       else
-        msg_error "Container creation failed even with local fallback. See $LOGFILE"
-        # Ask user if they want debug output
+        # --- Dynamic stack upgrade + auto-retry on the well-known error pattern ---
+        if grep -qiE 'unsupported .* version' "$LOGFILE"; then
+          echo
+          echo "pct reported 'unsupported ... version' – your LXC stack might be too old for this template."
+          echo "We can try to upgrade 'pve-container' and 'lxc-pve' now and retry automatically."
+          if offer_lxc_stack_upgrade_and_maybe_retry "yes"; then
+            : # success after retry
+          else
+            rc=$?
+            case $rc in
+            2) echo "Upgrade was declined. Please update and re-run:
+  apt update && apt install --only-upgrade pve-container lxc-pve" ;;
+            3) echo "Upgrade and/or retry failed. Please inspect: $LOGFILE" ;;
+            esac
+            exit 231
+          fi
+        else
+          msg_error "Container creation failed even with local fallback. See $LOGFILE"
+          if whiptail --yesno "pct create failed.\nDo you want to enable verbose debug mode and view detailed logs?" 12 70; then
+            set -x
+            bash -x -c "pct create $CTID local:vztmpl/${TEMPLATE} ${PCT_OPTIONS[*]}" 2>&1 | tee -a "$LOGFILE"
+            set +x
+          fi
+          exit 209
+        fi
+      fi
+    else
+      msg_error "Container creation failed on local storage. See $LOGFILE"
+      # --- Dynamic stack upgrade + auto-retry on the well-known error pattern ---
+      if grep -qiE 'unsupported .* version' "$LOGFILE"; then
+        echo
+        echo "pct reported 'unsupported ... version' – your LXC stack might be too old for this template."
+        echo "We can try to upgrade 'pve-container' and 'lxc-pve' now and retry automatically."
+        if offer_lxc_stack_upgrade_and_maybe_retry "yes"; then
+          : # success after retry
+        else
+          rc=$?
+          case $rc in
+          2) echo "Upgrade was declined. Please update and re-run:
+  apt update && apt install --only-upgrade pve-container lxc-pve" ;;
+          3) echo "Upgrade and/or retry failed. Please inspect: $LOGFILE" ;;
+          esac
+          exit 231
+        fi
+      else
         if whiptail --yesno "pct create failed.\nDo you want to enable verbose debug mode and view detailed logs?" 12 70; then
           set -x
           bash -x -c "pct create $CTID local:vztmpl/${TEMPLATE} ${PCT_OPTIONS[*]}" 2>&1 | tee -a "$LOGFILE"
@@ -525,28 +608,20 @@ if ! pct create "$CTID" "${TEMPLATE_STORAGE}:vztmpl/${TEMPLATE}" "${PCT_OPTIONS[
         fi
         exit 209
       fi
-    else
-      msg_error "Container creation failed on local storage. See $LOGFILE"
-      if whiptail --yesno "pct create failed.\nDo you want to enable verbose debug mode and view detailed logs?" 12 70; then
-        set -x
-        bash -x -c "pct create $CTID local:vztmpl/${TEMPLATE} ${PCT_OPTIONS[*]}" 2>&1 | tee -a "$LOGFILE"
-        set +x
-      fi
-      exit 209
     fi
   fi
 fi
 
 # Verify container exists
-if ! pct list | awk '{print $1}' | grep -qx "$CTID"; then
+pct list | awk '{print $1}' | grep -qx "$CTID" || {
   msg_error "Container ID $CTID not listed in 'pct list'. See $LOGFILE"
   exit 215
-fi
+}
 
 # Verify config rootfs
-if ! grep -q '^rootfs:' "/etc/pve/lxc/$CTID.conf"; then
+grep -q '^rootfs:' "/etc/pve/lxc/$CTID.conf" || {
   msg_error "RootFS entry missing in container config. See $LOGFILE"
   exit 216
-fi
+}
 
 msg_ok "LXC Container ${BL}$CTID${CL} ${GN}was successfully created."