diff --git a/.utils/scrape-and-inject-latest-gradle-wrapper.mjs b/.utils/scrape-and-inject-latest-gradle-wrapper.mjs
index cbd6f262..c9b7c54a 100644
--- a/.utils/scrape-and-inject-latest-gradle-wrapper.mjs
+++ b/.utils/scrape-and-inject-latest-gradle-wrapper.mjs
@@ -83,11 +83,11 @@ async function updateGradleWrapperFileContent({ latestGradleVersion, latestGradl
     if (compareVersionStrings(propVersion, majorVersionLimit) > 0) {
         const suffix = ` (downgrade, limited by "${config.majorVersionLimit}")`;
         messages.push(`-- ${propUrl}\n-> ${latestGradleUrl}${suffix}`);
-        props[KEY] = propUrl.replace(re, `$1${latestGradleVersion}$3`);
+        props.set(KEY, propUrl.replace(re, `$1${latestGradleVersion}$3`));
     } else if (compareVersionStrings(propVersion, latestGradleVersion) < 0) {
         const suffix = isVersionLimited() ? ` (upgrade, but limited by "${config.majorVersionLimit}")` : ` (upgrade)`;
         messages.push(`-- ${propUrl}\n-> ${latestGradleUrl}${suffix}`);
-        props[KEY] = propUrl.replace(re, `$1${latestGradleVersion}$3`);
+        props.set(KEY, propUrl.replace(re, `$1${latestGradleVersion}$3`));
     }
 
     if (messages.length > 0) {
diff --git a/build-logic/build.gradle.kts b/build-logic/build.gradle.kts
index 90c37c80..ff130e8b 100644
--- a/build-logic/build.gradle.kts
+++ b/build-logic/build.gradle.kts
@@ -1,3 +1,4 @@
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
 import java.util.*
 
 plugins {
@@ -9,41 +10,128 @@ repositories {
     google()
 }
 
-gradle.extra["jdk"] = run determineBuildLogicJdk@{
-    val propsFile: File = rootDir.parentFile.resolve("version.properties")
-    val minSupported: Int = Properties().let { props ->
-        require(propsFile.isFile) {
-            "version.properties not found in root directory"
-        }
+run determineBuildLogicJdk@{
+
+    val props = Properties().also { props ->
+        val propsFile: File = rootDir.parentFile.resolve("version.properties")
+        require(propsFile.isFile) { "version.properties not found in root directory" }
         propsFile.inputStream().use { props.load(it) }
-        val minSupportedVersion = props.getProperty("JAVA_VERSION_MIN_SUPPORTED")
-        require(minSupportedVersion != null) {
-            "version.properties does not contain \"JAVA_VERSION_MIN_SUPPORTED\""
+    }
+
+    fun Properties.requireIntProperty(key: String): Int = getProperty(key).also {
+        requireNotNull(it) { "version.properties does not contain \"$key\"" }
+    }.toInt()
+
+    val javaVersionMinSupported = props.requireIntProperty("JAVA_VERSION_MIN_SUPPORTED")
+    val javaVersionMaxSupported = props.requireIntProperty("JAVA_VERSION_MAX_SUPPORTED")
+    val javaVersionMinSuggested = props.requireIntProperty("JAVA_VERSION_MIN_SUGGESTED")
+
+    val javaVersionCurrentInt = JavaVersion.current().majorVersion.toInt()
+
+    fun validateCurrentVersion(versionInt: Int, name: String) {
+        if (versionInt < javaVersionMinSupported) {
+            throw GradleException("Current \"$name\" version [$versionInt] does not meet the minimum requirement which [$javaVersionMinSupported] is needed.")
+        }
+        if (versionInt < javaVersionMinSuggested) {
+            val suffix = if (javaVersionMaxSupported > 0) " (but not higher than [$javaVersionMaxSupported])" else ""
+            logger.error("It is recommended to upgrade current \"$name\" version [$versionInt] to [$javaVersionMinSuggested] or higher$suffix.")
+        }
+        if (versionInt > javaVersionMaxSupported) {
+            val suffix = if (javaVersionMaxSupported > javaVersionMinSuggested) " or lower (but not lower than [$javaVersionMinSuggested])" else ""
+            logger.error("It is recommended to downgrade current \"$name\" version [$versionInt] to [$javaVersionMaxSupported]$suffix, as Gradle may be not compatible with JDK [$versionInt] for now.")
         }
-        minSupportedVersion.toInt()
     }
-    val current = JavaVersion.current().majorVersion.toIntOrNull() ?: minSupported
 
-    fun tryAdjustByKotlinJvmTarget(sourceVersion: Int): Int {
-        return runCatching {
-            val cls = Class.forName("org.jetbrains.kotlin.gradle.dsl.JvmTarget")
-            val enumConstants = cls.enumConstants ?: return sourceVersion
-            var tmpVersion = sourceVersion
-            while (tmpVersion > minSupported) {
-                val wanted = "JVM_$tmpVersion"
-                if (enumConstants.any { it?.toString().equals(wanted, ignoreCase = true) }) {
-                    return tmpVersion
-                }
-                tmpVersion -= 1
+    validateCurrentVersion(versionInt = javaVersionCurrentInt, name = "Gradle JDK")
+
+    fun isJvmTargetAvailable(target: Int): Boolean {
+        try {
+            // Weak dependency with Kotlin plugin: Use reflection to check if JvmTarget is available;
+            // if reflection fails, treat it as available (to avoid incorrect downgrading).
+            // zh-CN: 与 Kotlin 插件弱依赖: 反射判断 JvmTarget 是否可用; 反射失败则视为可用 (避免误降级).
+            JvmTarget::class.java.enumConstants?.let { values ->
+                return values.any { it?.toString().equals("JVM_$target", true) }
             }
-            return@runCatching sourceVersion
-        }.getOrDefault(sourceVersion)
+        } catch (e: Throwable) {
+            logger.error("Failed to check JVM target availability: $e")
+        }
+        return true
     }
 
-    tryAdjustByKotlinJvmTarget(maxOf(current, minSupported)).also {
-        println("Toolchain: selected [$it] / current [$current] / min [$minSupported]")
+    val (versionInt, versionSuffix) = run determineJavaVersion@{
+        System.getProperty("gradle.java.version.overridden.by.user").toIntOrNull()?.let {
+            validateCurrentVersion(versionInt = it, name = "User Specified Java Version")
+            return@determineJavaVersion it to " [user-specified]"
+        }
+
+        var javaVersionInfoSuffix = ""
+        var versionInt = JavaVersion.current().majorVersion.toInt()
+
+        run tryAdjustJavaVersionByKotlinJvmTarget@{
+            var isJvmCoercive = false
+
+            while (versionInt > javaVersionMinSupported) {
+                if (isJvmTargetAvailable(versionInt)) {
+                    break
+                }
+                versionInt -= 1
+                isJvmCoercive = true
+            }
+
+            if (isJvmCoercive) {
+                javaVersionInfoSuffix += " [coercive-jvm-downgraded]"
+            }
+        }
+
+        System.getProperty("gradle.java.version.coerced.by.gradle").toIntOrNull()?.let {
+            if (versionInt > it) {
+                versionInt = it
+                javaVersionInfoSuffix += " [coercive-gradle-downgraded]"
+            }
+        }
+        return@determineJavaVersion versionInt to javaVersionInfoSuffix
     }
-}.also { jdk ->
-    kotlin { jvmToolchain(jdk) }
-    java { toolchain.languageVersion.set(JavaLanguageVersion.of(jdk)) }
+
+    System.setProperty("gradle.java.version.select", "$versionInt")
+    System.setProperty("gradle.java.version.suffix", versionSuffix)
+
+    println("JDK versions: min [$javaVersionMinSupported] / select [$versionInt] / current [$javaVersionCurrentInt] / max [$javaVersionMaxSupported]")
+
+    val (jvmTargetSelectInt, jvmTargetMaxInt) = run determineJvmTarget@{
+        var selected = versionInt
+        while (selected > javaVersionMinSupported) {
+            if (isJvmTargetAvailable(selected)) {
+                break
+            }
+            selected -= 1
+        }
+
+        var max = javaVersionMinSupported
+        while (isJvmTargetAvailable(max)) {
+            max += 1
+        }
+        max -= 1
+
+        return@determineJvmTarget selected to max
+    }
+
+    System.setProperty("gradle.jvm.target.effective", "$jvmTargetSelectInt")
+
+    println("JVM target: min [${javaVersionMinSupported}] / select [$jvmTargetSelectInt] / max [$jvmTargetMaxInt]")
+
+    java {
+        toolchain {
+            languageVersion.set(JavaLanguageVersion.of(versionInt))
+        }
+    }
+
+    kotlin {
+        jvmToolchain(versionInt)
+        compilerOptions {
+            jvmTarget.set(JvmTarget.fromTarget("$jvmTargetSelectInt"))
+        }
+    }
+
+    return@determineBuildLogicJdk versionInt
+
 }
diff --git a/build-logic/convention/build.gradle.kts b/build-logic/convention/build.gradle.kts
index 88fb7bbe..3aa52f79 100644
--- a/build-logic/convention/build.gradle.kts
+++ b/build-logic/convention/build.gradle.kts
@@ -1,3 +1,5 @@
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+
 plugins {
     `kotlin-dsl` /* kotlin("jvm") */
     `java-gradle-plugin`
@@ -56,7 +58,25 @@ gradlePlugin {
     }
 }
 
-(gradle.extra["jdk"] as Int).let { jdk ->
-    kotlin { jvmToolchain(jdk) }
-    java { toolchain.languageVersion.set(JavaLanguageVersion.of(jdk)) }
+System.getProperty("gradle.java.version.select").toInt().let { jdk ->
+    java {
+        toolchain {
+            languageVersion.set(JavaLanguageVersion.of(jdk))
+        }
+    }
+    kotlin {
+        jvmToolchain(jdk)
+    }
+}
+
+System.getProperty("gradle.jvm.target.effective").let { jvm ->
+    java {
+        sourceCompatibility = JavaVersion.toVersion(jvm)
+        targetCompatibility = JavaVersion.toVersion(jvm)
+    }
+    kotlin {
+        compilerOptions {
+            jvmTarget.set(JvmTarget.fromTarget(jvm))
+        }
+    }
 }
diff --git a/build-logic/convention/src/main/kotlin/org/autojs/build/Utils.kt b/build-logic/convention/src/main/kotlin/org/autojs/build/Utils.kt
index 0d92ab9e..0ea0622a 100644
--- a/build-logic/convention/src/main/kotlin/org/autojs/build/Utils.kt
+++ b/build-logic/convention/src/main/kotlin/org/autojs/build/Utils.kt
@@ -1,6 +1,7 @@
 package org.autojs.build
 
 import org.gradle.api.Action
+import org.gradle.api.JavaVersion
 import org.gradle.api.Project
 import org.gradle.api.Task
 import org.gradle.api.file.CopySpec
@@ -251,16 +252,16 @@ object Utils {
         val installer = {
             project.logInfo("[JvmConv] Detected Android plugin in module='${project.path}', installing configuration")
 
-            // Java: Use Toolchain (module-level + task-level), do not set --release.
-            // zh-CN: Java: 使用 Toolchain (模块级 + 任务级), 不要设置 --release.
+            System.getProperty("gradle.java.version.select").let { ver ->
+                configureJavaToolchainLanguageLevel(project, ver)
+                configureJavaToolchainForAllJavaCompile(project, ver)
+                configureKotlinJvmToolchain(project, ver)
+            }
 
-            configureJavaToolchainLanguageLevel(project, versions.javaVersionInt)
-            configureJavaToolchainForAllJavaCompile(project, versions.javaVersionInt)
-
-            // Kotlin: Continue lazy configuration to set jvmTarget.
-            // zh-CN: Kotlin: 继续懒配置设置 jvmTarget.
-
-            configureKotlinJvmTargetLazily(project, versions)
+            System.getProperty("gradle.jvm.target.effective").let { ver ->
+                configureAndroidCompileOptions(project, ver)
+                configureKotlinJvmTargetLazily(project, ver)
+            }
 
             project.logInfo("[JvmConv] Installed Java toolchain (module+tasks) and Kotlin jvmTarget for '${project.path}'")
         }
@@ -271,7 +272,7 @@ object Utils {
 
     // Module-level toolchain: Let AGP/Gradle know which JDK language level should be used for this module.
     // zh-CN: 模块级 Toolchain: 让 AGP/Gradle 知道本模块应使用的 JDK 语言级别.
-    private fun configureJavaToolchainLanguageLevel(project: Project, target: Int) {
+    private fun configureJavaToolchainLanguageLevel(project: Project, target: String) {
         val javaExt = project.extensions.findByType(JavaPluginExtension::class.java)
         if (javaExt == null) {
             project.logWarn("[JvmConv] JavaPluginExtension not found in '${project.path}', skip module-level toolchain")
@@ -286,9 +287,24 @@ object Utils {
         }
     }
 
+    private fun configureKotlinJvmToolchain(project: Project, target: String) {
+        project.plugins.withId("org.jetbrains.kotlin.android") {
+            project.extensions.findByName("kotlin")?.let { kotlinExt ->
+                runCatching {
+                    kotlinExt.javaClass.getMethod("jvmToolchain", Int::class.java)
+                        .invoke(kotlinExt, target.toInt())
+                }.onSuccess {
+                    project.logInfo("[JvmConv] Kotlin jvmToolchain set to $target for '${project.path}'")
+                }.onFailure {
+                    project.logError("[JvmConv] Set Kotlin jvmToolchain failed on '${project.path}': ${it.message}", it)
+                }
+            }
+        }
+    }
+
     // Task-level Toolchain: Specify javaCompiler for all JavaCompile tasks, without setting --release (prohibited by AGP).
     // zh-CN: 任务级 Toolchain: 对所有 JavaCompile 指定 javaCompiler, 且不要设置 --release (AGP 禁止).
-    private fun configureJavaToolchainForAllJavaCompile(project: Project, target: Int) {
+    private fun configureJavaToolchainForAllJavaCompile(project: Project, target: String) {
         val toolchains = runCatching {
             project.extensions.getByType(JavaToolchainService::class.java)
         }.onFailure {
@@ -309,6 +325,37 @@ object Utils {
         })
     }
 
+    // 将 Android 的 compileOptions.sourceCompatibility/targetCompatibility 设置为给定目标 (如 "24"), 确保与 Kotlin 一致
+    // zh-CN: 使用反射避免对 AGP 具体类型的直接依赖; 兼容 application/library.
+    private fun configureAndroidCompileOptions(project: Project, target: String) {
+        val androidExt = project.extensions.findByName("android") ?: run {
+            project.logWarn("[JvmConv] Android extension not found in '${project.path}', skip compileOptions alignment")
+            return
+        }
+        runCatching {
+            val compileOptions = androidExt.javaClass.methods
+                .firstOrNull { it.name == "getCompileOptions" && it.parameterTypes.isEmpty() }
+                ?.invoke(androidExt) ?: return@runCatching project.logWarn("[JvmConv] compileOptions not found on android extension for '${project.path}'")
+
+            val javaVersionClass = Class.forName("org.gradle.api.JavaVersion")
+            val javaVersion = JavaVersion.toVersion(target)
+
+            val setSource = compileOptions.javaClass.methods.firstOrNull {
+                it.name == "setSourceCompatibility" && it.parameterTypes.size == 1 && it.parameterTypes[0] == javaVersionClass
+            } ?: throw IllegalStateException("setSourceCompatibility(JavaVersion) not found")
+            val setTarget = compileOptions.javaClass.methods.firstOrNull {
+                it.name == "setTargetCompatibility" && it.parameterTypes.size == 1 && it.parameterTypes[0] == javaVersionClass
+            } ?: throw IllegalStateException("setTargetCompatibility(JavaVersion) not found")
+
+            setSource.invoke(compileOptions, javaVersion)
+            setTarget.invoke(compileOptions, javaVersion)
+
+            project.logInfo("[JvmConv] Android compileOptions source/target set to Java $target for '${project.path}'")
+        }.onFailure {
+            project.logError("[JvmConv] Configure Android compileOptions failed on '${project.path}': ${it.message}", it)
+        }
+    }
+
     // Configure jvmTarget for KotlinCompile tasks:
     // Use configureEach for lazy configuration on task creation;
     // Compatible with old and new APIs.
@@ -316,8 +363,8 @@ object Utils {
     // 为 KotlinCompile 任务设置 jvmTarget:
     // 使用 configureEach, 任务实现时自动应用;
     // 兼容新旧 API.
-    private fun configureKotlinJvmTargetLazily(project: Project, versions: Versions) {
-        val desiredStr = versions.javaVersionString // e.g. "22"
+    private fun configureKotlinJvmTargetLazily(project: Project, target: String) {
+        val desiredStr = target // e.g. "22"
         val desiredEnumName = "JVM_${desiredStr}" // e.g. "JVM_22"
         project.logInfo("[JvmConv] Will configure Kotlin jvmTarget lazily to '$desiredEnumName' in '${project.path}'")
 
diff --git a/build-logic/convention/src/main/kotlin/org/autojs/build/Versions.kt b/build-logic/convention/src/main/kotlin/org/autojs/build/Versions.kt
index f4ec4f77..8c724a45 100644
--- a/build-logic/convention/src/main/kotlin/org/autojs/build/Versions.kt
+++ b/build-logic/convention/src/main/kotlin/org/autojs/build/Versions.kt
@@ -2,7 +2,6 @@ package org.autojs.build
 
 import org.autojs.build.Utils.getOrNull
 import org.gradle.api.Action
-import org.gradle.api.GradleException
 import org.gradle.api.JavaVersion
 import org.gradle.api.Project
 import org.gradle.api.execution.TaskExecutionGraph
@@ -10,7 +9,6 @@ import org.gradle.kotlin.dsl.extra
 import java.io.FileInputStream
 import java.io.FileOutputStream
 import java.util.*
-import kotlin.properties.Delegates
 import kotlin.text.RegexOption.IGNORE_CASE
 
 class Versions @JvmOverloads constructor(
@@ -18,15 +16,16 @@ class Versions @JvmOverloads constructor(
     filePath: String = "${project.rootDir}/version.properties",
 ) {
     private val gradle = project.gradle
-    private val logger = project.logger
-
-    private val currentVersionInt = JavaVersion.current().majorVersion.toInt()
 
     private val bp = BuildProperties.loadFrom(filePath)
 
-    private val javaVersionMinSuggested: Int = bp.requireInt("JAVA_VERSION_MIN_SUGGESTED")
+    private val javaVersionCurrentInt = JavaVersion.current().majorVersion.toInt()
+    private val javaVersionMinSupported: Int = bp.requireInt("JAVA_VERSION_MIN_SUPPORTED")
     private val javaVersionMaxSupported: Int = bp.requireInt("JAVA_VERSION_MAX_SUPPORTED")
 
+    private val javaVersionInt: Int = System.getProperty("gradle.java.version.select").toInt()
+    private val javaVersionInfoSuffix: String = System.getProperty("gradle.java.version.suffix", "")
+
     private var isBuildNumberAutoIncremented = false
     private val minBuildTimeGap = Utils.hours2Millis(0.75)
 
@@ -41,93 +40,12 @@ class Versions @JvmOverloads constructor(
     val appVersionCode = bp.requireInt("VERSION_BUILD")
     val vscodeExtRequiredVersion = bp.requireString("VSCODE_EXT_REQUIRED_VERSION")
 
-    private val javaVersionMinSupported: Int = bp.requireInt("JAVA_VERSION_MIN_SUPPORTED")
-
-    var javaVersionInt by Delegates.notNull<Int>()
-    var javaVersionInfoSuffix by Delegates.notNull<String>()
-
     val javaVersion: JavaVersion
         get() = JavaVersion.toVersion(javaVersionInt)
 
     val javaVersionString: String
         get() = javaVersion.toString()
 
-    init {
-        validateCurrentVersion()
-        determineJavaVersion().also { (javaVersionInt, javaVersionInfoSuffix) ->
-            this.javaVersionInt = javaVersionInt
-            this.javaVersionInfoSuffix = javaVersionInfoSuffix
-        }
-    }
-
-    private fun validateCurrentVersion() {
-        if (gradle.extra.getOrNull<Boolean>(VALIDATED_EXTRA_KEY) == true) {
-            return
-        }
-        if (currentVersionInt < javaVersionMinSupported) {
-            throw GradleException("Current Gradle JDK version [$currentVersionInt] does not meet the minimum requirement which [$javaVersionMinSupported] is needed.")
-        }
-        if (currentVersionInt < javaVersionMinSuggested) {
-            val suffix = if (javaVersionMaxSupported > 0) " (but not higher than [$javaVersionMaxSupported])" else ""
-            logger.error("It is recommended to upgrade current Gradle JDK version [$currentVersionInt] to [$javaVersionMinSuggested] or higher$suffix.")
-        }
-        if (currentVersionInt > javaVersionMaxSupported) {
-            val suffix = if (javaVersionMaxSupported > javaVersionMinSuggested) " or lower (but not lower than [$javaVersionMinSuggested])" else ""
-            logger.error("It is recommended to downgrade current Gradle JDK version [$currentVersionInt] to [$javaVersionMaxSupported]$suffix, as Gradle may be not compatible with JDK [$currentVersionInt] for now.")
-        }
-        gradle.extra.set(VALIDATED_EXTRA_KEY, true)
-    }
-
-    private fun determineJavaVersion(): Pair<Int, String> {
-        var javaVersionInfoSuffix = ""
-
-        gradle.extra.getOrNull<Int>("javaVersionOverriddenByUser")?.let {
-            javaVersionInfoSuffix += " [user-specified]"
-            return it to javaVersionInfoSuffix
-        }
-
-        var versionInt = JavaVersion.current().majorVersion.toInt()
-
-        run tryAdjustJavaVersionByKotlinJvmTarget@{
-            var isJvmCoercive = false
-
-            while (versionInt > javaVersionMinSupported) {
-                if (isJvmTargetAvailable(versionInt)) {
-                    break
-                }
-                versionInt -= 1
-                isJvmCoercive = true
-            }
-
-            if (isJvmCoercive) {
-                javaVersionInfoSuffix += " [coercive-jvm-downgraded]"
-            }
-        }
-
-        gradle.extra.getOrNull<Int>("javaVersionCoercedByGradle")?.let {
-            if (versionInt > it) {
-                versionInt = it
-                javaVersionInfoSuffix += " [coercive-gradle-downgraded]"
-            }
-        }
-        return versionInt to javaVersionInfoSuffix
-    }
-
-    private fun isJvmTargetAvailable(target: Int): Boolean {
-        try {
-            // Weak dependency with Kotlin plugin: Use reflection to check if JvmTarget is available;
-            // if reflection fails, treat it as available (to avoid incorrect downgrading).
-            // zh-CN: 与 Kotlin 插件弱依赖: 反射判断 JvmTarget 是否可用; 反射失败则视为可用 (避免误降级).
-            val cls = Class.forName("org.jetbrains.kotlin.gradle.dsl.JvmTarget")
-            cls.enumConstants?.let { values ->
-                return values.any { it?.toString().equals("JVM_$target", true) }
-            }
-        } catch (e: Throwable) {
-            logger.error("Failed to check JVM target availability: $e")
-        }
-        return true
-    }
-
     operator fun get(propertyName: String) = bp[propertyName]
 
     operator fun get(propertyInfo: List<String>) = bp[propertyInfo]
@@ -138,6 +56,7 @@ class Versions @JvmOverloads constructor(
         val infoVerName = "Version name: $appVersionName"
         val infoVerCode = "Version code: ${if (isBuildNumberAutoIncremented) "${appVersionCode + 1} [auto-incremented]" else appVersionCode}"
         val infoVerSdk = "SDK versions: min [$sdkVersionMin] / target [$sdkVersionTarget] / compile [$sdkVersionCompile]"
+        val infoVerJdk = "JDK versions: min [$javaVersionMinSupported] / select [$javaVersionInt] / current [$javaVersionCurrentInt] / max [$javaVersionMaxSupported]"
         val infoVerJava = "Java version: $javaVersion${
             when {
                 gradle.extra.getOrNull<Boolean>("isHideConsoleInfoHintSuffix") == true -> ""
@@ -145,7 +64,7 @@ class Versions @JvmOverloads constructor(
             }
         }"
 
-        val maxLength = arrayOf(title, infoVerName, infoVerCode, infoVerSdk, infoVerJava).maxOf { it.length }
+        val maxLength = arrayOf(title, infoVerName, infoVerCode, infoVerSdk, infoVerJdk, infoVerJava).maxOf { it.length }
 
         arrayOf(
             "=".repeat(maxLength),
@@ -154,6 +73,7 @@ class Versions @JvmOverloads constructor(
             infoVerName,
             infoVerCode,
             infoVerSdk,
+            infoVerJdk,
             infoVerJava,
             "=".repeat(maxLength),
             "",
@@ -203,8 +123,4 @@ class Versions @JvmOverloads constructor(
         }
     }
 
-    companion object {
-        private const val VALIDATED_EXTRA_KEY = "org.autojs.build.Versions.currentValidated"
-    }
-
 }
diff --git a/build-logic/ksp-version-codes-processor/build.gradle.kts b/build-logic/ksp-version-codes-processor/build.gradle.kts
index b90be0dc..6b74d6d4 100644
--- a/build-logic/ksp-version-codes-processor/build.gradle.kts
+++ b/build-logic/ksp-version-codes-processor/build.gradle.kts
@@ -1,5 +1,7 @@
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+
 plugins {
-    kotlin("jvm")
+    `kotlin-dsl`
 }
 
 repositories {
@@ -9,12 +11,30 @@ repositories {
 
 dependencies {
     implementation(gradleApi())
-    implementation(kotlin("stdlib"))
+
     implementation("com.google.devtools.ksp:symbol-processing-api:${System.getProperty("com.google.devtools.ksp")}")
     implementation(libs.kotlin.csv.jvm)
 }
 
-(gradle.extra["jdk"] as Int).let { jdk ->
-    kotlin { jvmToolchain(jdk) }
-    java { toolchain.languageVersion.set(JavaLanguageVersion.of(jdk)) }
+System.getProperty("gradle.java.version.select").toInt().let { jdk ->
+    java {
+        toolchain {
+            languageVersion.set(JavaLanguageVersion.of(jdk))
+        }
+    }
+    kotlin {
+        jvmToolchain(jdk)
+    }
 }
+
+System.getProperty("gradle.jvm.target.effective").let { jvm ->
+    java {
+        sourceCompatibility = JavaVersion.toVersion(jvm)
+        targetCompatibility = JavaVersion.toVersion(jvm)
+    }
+    kotlin {
+        compilerOptions {
+            jvmTarget.set(JvmTarget.fromTarget(jvm))
+        }
+    }
+}
\ No newline at end of file
diff --git a/gradle/data/agp-releases.list b/gradle/data/agp-releases.list
index c6b20070..34c626a9 100644
--- a/gradle/data/agp-releases.list
+++ b/gradle/data/agp-releases.list
@@ -1,6 +1,6 @@
-#Fri Nov 07 07:37:56 GMT+8 2025
+#Wed Nov 12 14:20:31 GMT+8 2025
 9.0.0-alpha14
-8.13.0
+8.13.1
 8.12.3
 8.11.2
 8.10.1
diff --git a/settings.gradle.kts b/settings.gradle.kts
index 5a19bc29..13c3dc17 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -127,6 +127,7 @@ pluginManagement {
             putAll(gradle.startParameter.projectProperties)
         }.filterKeys { key ->
             return@filterKeys key is String
+                    && key.startsWith("gradle.").not()
                     && key !in unconcernedKeys
                     && key.split(Regex("\\W")).any { it in concernedKeyWords }
                     && key.split(Regex("\\W")).none { it in unconcernedKeyWords }
@@ -421,15 +422,15 @@ pluginManagement {
                     || systemProperties.vendorName?.contains(vendor, true) == true
 
             fun ensureMinimalGradleJdkVersion() {
-                val minVer = versionProps["JAVA_VERSION_MIN_SUPPORTED"].let { it as String }.toInt()
+                val javaVersionMinSupported = versionProps["JAVA_VERSION_MIN_SUPPORTED"].let { it as String }.toInt()
 
-                if (JavaVersion.current().majorVersion.toInt() < minVer) {
+                if (JavaVersion.current().majorVersion.toInt() < javaVersionMinSupported) {
                     Formatted(
                         "Current Gradle JDK version ${JavaVersion.current()} does not meet " +
-                                "the minimum requirement which $minVer is needed",
+                                "the minimum requirement which $javaVersionMinSupported is needed",
                         mutableListOf<String>().apply {
                             gradleSettingsName?.let { add("Settings path: File | Settings | Build, Execution, Deployment | Build Tools | Gradle") }
-                            add("Change \"${gradleSettingsName ?: "Gradle JDK"}\" to $minVer at the least")
+                            add("Change \"${gradleSettingsName ?: "Gradle JDK"}\" to $javaVersionMinSupported at the least")
                         }
                     ).throwException()
                 }
@@ -655,8 +656,8 @@ pluginManagement {
                 }
             }
             if (lib.id == "com.android.tools.build:gradle") {
-                gradle.extra.set("javaVersionCoercedByGradle", getMaxSupportedJavaVersion(version))
-                gradle.extra.set("javaVersionOverriddenByUser", overriddenJavaVersion)
+                System.setProperty("gradle.java.version.coerced.by.gradle", "${getMaxSupportedJavaVersion(version)}")
+                System.setProperty("gradle.java.version.overridden.by.user", "$overriddenJavaVersion")
             }
             "${lib.id}:$version".also { notation ->
                 console.versionInfo += "Classpath: \"$notation\"${if (config.isHideConsoleInfoHintSuffix) "" else suffix}"
diff --git a/version.properties b/version.properties
index 614eb110..6698ed56 100644
--- a/version.properties
+++ b/version.properties
@@ -1,9 +1,9 @@
-#Mon Nov 10 16:46:18 CST 2025
-BUILD_TIME=1762764378596
+#Wed Nov 12 23:59:03 CST 2025
+BUILD_TIME=1762963143554
 COMPILE_SDK_VERSION=36
 IMAGE_QUANT_CMAKE_VERSION=3.22.1
 IMAGE_QUANT_NDK_VERSION=26.1.10909125
-JAVA_VERSION_MAX_SUPPORTED=24
+JAVA_VERSION_MAX_SUPPORTED=25
 JAVA_VERSION_MIN_SUGGESTED=21
 JAVA_VERSION_MIN_SUPPORTED=17
 MIN_SDK_VERSION=24
@@ -27,6 +27,6 @@ RAPID_OCR_OPENCV_MOBILE_LABEL_VERSION=13
 RAPID_OCR_OPENCV_MOBILE_VERSION=4.5.3
 TARGET_SDK_VERSION=36
 TARGET_SDK_VERSION_INRT=29
-VERSION_BUILD=3484
+VERSION_BUILD=3487
 VERSION_NAME=6.7.0 Alpha11
 VSCODE_EXT_REQUIRED_VERSION=1.0.8