Scripting: support plugins loading in the stateless REPL
diff --git a/libraries/examples/scripting/jsr223-bta/build.gradle.kts b/libraries/examples/scripting/jsr223-bta/build.gradle.kts
index 4985f59b..365eee0 100644
--- a/libraries/examples/scripting/jsr223-bta/build.gradle.kts
+++ b/libraries/examples/scripting/jsr223-bta/build.gradle.kts
@@ -27,7 +27,7 @@
     testImplementation(project(":kotlin-script-runtime")) // marker class to locate the jar for legacy-template tests
     // MainKtsConfigurator instantiates a MavenDependenciesResolver in a default constructor
     // argument, so this is needed even though no test resolves dependencies.
-    testRuntimeOnly(project(":kotlin-scripting-dependencies-maven"))
+    testImplementation(project(":kotlin-scripting-dependencies-maven"))
 }
 
 // The Build Tools API implementation plus the compiler it runs on, loaded into an isolated
@@ -38,11 +38,19 @@
 // The scripting plugin jar, which has to be the regular (non-relocated) embeddable artifact to match
 // the embeddable compiler above.
 val scriptingCompilerPluginClasspath = configurations.create("scriptingCompilerPluginClasspath")
+val kotlinxSerializationCompilerPluginClasspath = configurations.create("kotlinxSerializationCompilerPluginClasspath")
+val allOpenCompilerPluginClasspath = configurations.create("allOpenCompilerPluginClasspath")
 
 dependencies {
     add(btaImplClasspath.name, project(":compiler:build-tools:kotlin-build-tools-impl"))
     add(btaImplClasspath.name, project(":compiler:build-tools:kotlin-build-tools-compat"))
     add(scriptingCompilerPluginClasspath.name, project(":kotlin-scripting-compiler-embeddable"))
+    add(kotlinxSerializationCompilerPluginClasspath.name, project(":kotlinx-serialization-compiler-plugin.embeddable")) {
+        isTransitive = false
+    }
+    add(allOpenCompilerPluginClasspath.name, project(":kotlin-allopen-compiler-plugin.embeddable")) {
+        isTransitive = false
+    }
 }
 
 sourceSets {
@@ -68,15 +76,25 @@
         workingDir = rootDir
         val btaImplClasspathFiles: FileCollection = btaImplClasspath
         val scriptingPluginClasspathFiles: FileCollection = scriptingCompilerPluginClasspath
+        val serializationPluginClasspathFiles: FileCollection = kotlinxSerializationCompilerPluginClasspath
         inputs.files(btaImplClasspathFiles)
             .withPropertyName("btaImplClasspath")
             .withNormalizer(ClasspathNormalizer::class)
         inputs.files(scriptingPluginClasspathFiles)
             .withPropertyName("scriptingCompilerPluginClasspath")
             .withNormalizer(ClasspathNormalizer::class)
+        inputs.files(serializationPluginClasspathFiles)
+            .withPropertyName("kotlinxSerializationCompilerPluginClasspath")
+            .withNormalizer(ClasspathNormalizer::class)
+        val allOpenPluginClasspathFiles: FileCollection = allOpenCompilerPluginClasspath
+        inputs.files(allOpenPluginClasspathFiles)
+            .withPropertyName("allOpenCompilerPluginClasspath")
+            .withNormalizer(ClasspathNormalizer::class)
         doFirst {
             systemProperty("kotlinJsr223BtaImplClasspath", btaImplClasspathFiles.asPath)
             systemProperty("kotlinJsr223BtaScriptingPluginClasspath", scriptingPluginClasspathFiles.asPath)
+            systemProperty("kotlin.script.test.kotlinx.serialization.plugin.classpath", serializationPluginClasspathFiles.asPath)
+            systemProperty("kotlin.script.test.allopen.plugin.classpath", allOpenPluginClasspathFiles.asPath)
         }
     }
 }
diff --git a/libraries/examples/scripting/jsr223-bta/src/org/jetbrains/kotlin/jsr223/bta/BtaReplCompiler.kt b/libraries/examples/scripting/jsr223-bta/src/org/jetbrains/kotlin/jsr223/bta/BtaReplCompiler.kt
index a2c2c21..e1cd071 100644
--- a/libraries/examples/scripting/jsr223-bta/src/org/jetbrains/kotlin/jsr223/bta/BtaReplCompiler.kt
+++ b/libraries/examples/scripting/jsr223-bta/src/org/jetbrains/kotlin/jsr223/bta/BtaReplCompiler.kt
@@ -5,25 +5,12 @@
 
 package org.jetbrains.kotlin.jsr223.bta
 
-import org.jetbrains.kotlin.buildtools.api.CompilationResult
-import org.jetbrains.kotlin.buildtools.api.DelicateBuildToolsApi
-import org.jetbrains.kotlin.buildtools.api.DeprecatedCompilerArgument
-import org.jetbrains.kotlin.buildtools.api.ExecutionPolicy
-import org.jetbrains.kotlin.buildtools.api.KotlinLogger
-import org.jetbrains.kotlin.buildtools.api.KotlinToolchains
-import org.jetbrains.kotlin.buildtools.api.arguments.CommonCompilerArguments
-import org.jetbrains.kotlin.buildtools.api.arguments.CompilerPlugin
-import org.jetbrains.kotlin.buildtools.api.arguments.CompilerPluginOption
-import org.jetbrains.kotlin.buildtools.api.arguments.ExperimentalCompilerArgument
-import org.jetbrains.kotlin.buildtools.api.arguments.JvmCompilerArguments
+import org.jetbrains.kotlin.buildtools.api.*
+import org.jetbrains.kotlin.buildtools.api.arguments.*
 import org.jetbrains.kotlin.buildtools.api.jvm.JvmPlatformToolchain.Companion.jvm
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.ScriptNames
-import org.jetbrains.kotlin.scripting.compiler.plugin.KOTLIN_SCRIPTING_PLUGIN_ID
-import org.jetbrains.kotlin.scripting.compiler.plugin.ReplSnippetConfigurationCodec
-import org.jetbrains.kotlin.scripting.compiler.plugin.ScriptTemplateWithClasspath
-import org.jetbrains.kotlin.scripting.compiler.plugin.scriptTemplateWithClasspath
-import org.jetbrains.kotlin.scripting.compiler.plugin.withRefinedFromSnippetClass
+import org.jetbrains.kotlin.scripting.compiler.plugin.*
 import java.io.File
 import java.io.IOException
 import java.nio.file.Files
@@ -87,6 +74,7 @@
 
     private val priorOutputDirs = mutableListOf<Path>()
     private val priorClassIds = mutableListOf<ClassId>()
+    private var plugins = StatelessReplCompilerPlugins.EMPTY
 
     private var scriptTemplateCache: Pair<Any, ScriptTemplateWithClasspath?>? = null
 
@@ -162,23 +150,50 @@
         try {
             val scriptFiles = refinedSnippets.map { sourceDir.resolve(it.name).also { file -> file.writeText(it.snippet.text) } }
 
-            logger.clear()
-            val result = runCompilation(scriptFiles, outputDir, configurationFile, batchConfiguration)
+            fun compile(output: Path, pluginSet: StatelessReplCompilerPlugins): CompilationResult {
+                logger.clear()
+                return runCompilation(scriptFiles, output, configurationFile, batchConfiguration, pluginSet)
+            }
+
+            var candidatePlugins = plugins
+            var finalOutputDir = outputDir
+            var result = compile(outputDir, candidatePlugins)
+            // The compiler reports compiler plugins requested by the snippets, but not loaded yet, in a dedicated diagnostic.
+            val requestedPlugins = try {
+                logger.messages.mapNotNull(StatelessReplPluginRequestsCodec::extractMissingPluginRequests)
+                    .takeIf { it.isNotEmpty() }?.flatten()
+            } catch (exception: Exception) {
+                return ResultWithDiagnostics.Failure(
+                    "BtaReplCompiler: unable to decode compiler plugin requests: ${exception.message}".asErrorDiagnostics()
+                )
+            }
+            if (requestedPlugins != null) {
+                candidatePlugins = plugins.merge(requestedPlugins).valueOr { return it }
+
+                finalOutputDir = Files.createDirectories(workRoot.resolve("snippet-batch-$batchIndex-retry-out"))
+                result = compile(finalOutputDir, candidatePlugins)
+                if (logger.messages.any { StatelessReplPluginRequestsCodec.extractMissingPluginRequests(it) != null }) {
+                    return ResultWithDiagnostics.Failure(
+                        "BtaReplCompiler: compiler requested plugins after its single retry".asErrorDiagnostics()
+                    )
+                }
+            }
+
             if (result != COMPILATION_SUCCESS) {
                 return ResultWithDiagnostics.Failure(
                     logger.messages.map { it.asErrorDiagnostics(path = refinedSnippets.last().snippet.locationId) }
                 )
             }
 
-            priorOutputDirs.add(outputDir)
+            priorOutputDirs.add(finalOutputDir)
             for ([refinedSnippet, scriptFile] in refinedSnippets.zip(scriptFiles)) {
                 val classId = snippetClassId(scriptFile)
                 // Brings in compiler-side refinement results, e.g. `@DependsOn`-resolved jars.
                 val compilationConfiguration = refinedSnippet.configuration.withRefinedFromSnippetClass(
-                    outputDir.resolve("${classId.shortClassName.asString()}.class").toFile()
+                    finalOutputDir.resolve("${classId.shortClassName.asString()}.class").toFile()
                 )
                 val compiledSnippet = compiledSnippetFromClassPath(
-                    classPath = listOf(outputDir.toFile()),
+                    classPath = listOf(finalOutputDir.toFile()),
                     snippetClassFQName = classId.asSingleFqName().asString(),
                     snippet = refinedSnippet.snippet,
                     compilationConfiguration = compilationConfiguration,
@@ -186,6 +201,7 @@
                 priorClassIds += classId
                 lastCompiledSnippetInternal = lastCompiledSnippetInternal.add(compiledSnippet)
             }
+            plugins = candidatePlugins
             reports += logger.messages.map {
                 ScriptDiagnostic(
                     ScriptDiagnostic.unspecifiedInfo, it, ScriptDiagnostic.Severity.WARNING,
@@ -198,19 +214,22 @@
         }
     }
 
-    @OptIn(ExperimentalCompilerArgument::class, DeprecatedCompilerArgument::class)
+    @OptIn(ExperimentalCompilerArgument::class)
     private fun runCompilation(
         scriptFiles: List<Path>,
         outputDir: Path,
         configurationFile: Path,
         batchConfiguration: ScriptCompilationConfiguration,
+        plugins: StatelessReplCompilerPlugins,
     ): CompilationResult {
         val operation = toolchain.jvm.jvmCompilationOperationBuilder(scriptFiles, outputDir)
         operation.compilerArguments.let { arguments ->
             arguments[JvmCompilerArguments.CLASSPATH] = additionalClasspath + priorSnippetsResolvedClasspath() + priorOutputDirs
             arguments[CommonCompilerArguments.X_ALLOW_ANY_SCRIPTS_IN_SOURCE_ROOTS] = true
             arguments[CommonCompilerArguments.X_SUPPRESS_VERSION_WARNINGS] = true
-            arguments[CommonCompilerArguments.COMPILER_PLUGINS] = listOf(scriptingPlugin(configurationFile, batchConfiguration))
+            arguments[CommonCompilerArguments.COMPILER_PLUGINS] =
+                listOf(scriptingPlugin(configurationFile, batchConfiguration, plugins)) +
+                        plugins.asBtaCompilerPlugins()
         }
         return session.executeOperation(operation.build(), executionPolicy, logger)
     }
@@ -219,7 +238,11 @@
      * The scripting compiler plugin declaration that switches this compilation into
      * chained-REPL-snippet mode.
      */
-    private fun scriptingPlugin(configurationFile: Path, batchConfiguration: ScriptCompilationConfiguration): CompilerPlugin =
+    private fun scriptingPlugin(
+        configurationFile: Path,
+        batchConfiguration: ScriptCompilationConfiguration,
+        plugins: StatelessReplCompilerPlugins,
+    ): CompilerPlugin =
         CompilerPlugin(
             pluginId = KOTLIN_SCRIPTING_PLUGIN_ID,
             classpath = scriptingPluginClasspath,
@@ -229,6 +252,9 @@
                     add(CompilerPluginOption("repl-snippet-prior-class", classId.asString()))
                 }
                 add(CompilerPluginOption("repl-snippet-configuration", configurationFile.toAbsolutePath().toString()))
+                plugins.loadedKeyOptions().forEach {
+                    add(CompilerPluginOption("repl-snippet-loaded-plugin", it))
+                }
                 // Refinement handlers are transient and cannot travel in the configuration file, so the compiler
                 // loads the definition from its template and overrides it with the configuration from the file.
                 scriptTemplateWithClasspathOf(batchConfiguration)?.let { template ->
@@ -243,6 +269,20 @@
             orderingRequirements = emptySet(),
         )
 
+    private fun StatelessReplCompilerPlugins.asBtaCompilerPlugins(): List<CompilerPlugin> =
+        entries().map { [_, pluginId, classpath, options] ->
+            CompilerPlugin(
+                pluginId = pluginId,
+                classpath = classpath.map { it.toPath() },
+                rawArguments = options.map { option ->
+                    val separator = option.indexOf('=')
+                    require(separator > 0) { "Invalid compiler plugin option '$option'." }
+                    CompilerPluginOption(option.substring(0, separator), option.substring(separator + 1))
+                },
+                orderingRequirements = emptySet(),
+            )
+        }
+
     private fun scriptTemplateWithClasspathOf(configuration: ScriptCompilationConfiguration): ScriptTemplateWithClasspath? {
         val key = configuration[ScriptCompilationConfiguration.baseClass] to
                 configuration[ScriptCompilationConfiguration.hostConfiguration]
diff --git a/libraries/examples/scripting/jsr223-bta/test/org/jetbrains/kotlin/jsr223/bta/test/KotlinJsr223BtaScriptEngineMainKtsTest.kt b/libraries/examples/scripting/jsr223-bta/test/org/jetbrains/kotlin/jsr223/bta/test/KotlinJsr223BtaScriptEngineMainKtsTest.kt
index be15cbd..1ef3c6a 100644
--- a/libraries/examples/scripting/jsr223-bta/test/org/jetbrains/kotlin/jsr223/bta/test/KotlinJsr223BtaScriptEngineMainKtsTest.kt
+++ b/libraries/examples/scripting/jsr223-bta/test/org/jetbrains/kotlin/jsr223/bta/test/KotlinJsr223BtaScriptEngineMainKtsTest.kt
@@ -14,9 +14,18 @@
 import org.junit.jupiter.api.Test
 import java.io.File
 import java.nio.file.Files
+import java.nio.file.Path
 import java.util.jar.JarEntry
 import java.util.jar.JarOutputStream
+import javax.script.ScriptException
 import kotlin.io.path.invariantSeparatorsPathString
+import kotlin.script.experimental.api.valueOrThrow
+import kotlin.script.experimental.dependencies.CompoundDependenciesResolver
+import kotlin.script.experimental.dependencies.maven.MavenDependenciesResolver
+import kotlin.script.experimental.impl.internalScriptingRunSuspend
+import kotlin.test.assertContains
+import kotlin.test.assertFailsWith
+import kotlin.test.assertTrue
 import kotlin.script.experimental.jvmhost.createJvmScriptDefinitionFromTemplate
 
 /**
@@ -27,12 +36,19 @@
 
     private val mainKtsScriptDefinition = createJvmScriptDefinitionFromTemplate<MainKtsScript>()
 
-    private fun newEngine(withMainKtsOnCompileClasspath: Boolean = false): KotlinJsr223BtaScriptEngineImpl {
+    private fun newEngine(
+        withMainKtsOnCompileClasspath: Boolean = false,
+        withSerializationRuntime: Boolean = false,
+    ): KotlinJsr223BtaScriptEngineImpl {
+        val additionalClasspath = buildList {
+            addAll(listOf(stdlibPath, scriptRuntimePath))
+            if (withSerializationRuntime) addAll(serializationRuntimeClasspath())
+            if (withMainKtsOnCompileClasspath) addAll(mainKtsPaths)
+        }
         val factory = KotlinJsr223BtaScriptEngineFactory(
             compilerClasspath = classpathFromSystemProperty("kotlinJsr223BtaImplClasspath"),
             scriptingPluginClasspath = classpathFromSystemProperty("kotlinJsr223BtaScriptingPluginClasspath"),
-            additionalClasspath = listOf(stdlibPath, scriptRuntimePath) +
-                    if (withMainKtsOnCompileClasspath) mainKtsPaths else emptyList(),
+            additionalClasspath = additionalClasspath,
             daemonRunFilesPath = daemonRunFilesPath,
             daemonLogsPath = daemonLogsPath,
             daemonShutdownDelayMillis = 0,
@@ -108,6 +124,142 @@
     }
 
     @Test
+    fun testSerializationCompilerPluginPersistsAcrossSnippets() {
+        val engine = newEngine(withMainKtsOnCompileClasspath = true, withSerializationRuntime = true)
+        assertEquals(
+            null,
+            engine.eval(
+                """
+                    ${serializationPluginAnnotation()}
+                    import kotlinx.serialization.Serializable
+
+                    @Serializable
+                    data class User(val name: String)
+                """.trimIndent()
+            )
+        )
+        assertEquals(
+            null,
+            engine.eval(
+                """
+                    ${serializationPluginAnnotation()}
+                    import kotlinx.serialization.Serializable
+
+                    @Serializable
+                    data class Project(val name: String)
+                """.trimIndent()
+            )
+        )
+
+        val descriptorNames = engine.eval(
+            "User.serializer().descriptor.serialName + \"|\" + Project.serializer().descriptor.serialName"
+        ).toString().split('|')
+        assertEquals(2, descriptorNames.size)
+        assertTrue(descriptorNames[0].endsWith(".User"))
+        assertTrue(descriptorNames[1].endsWith(".Project"))
+    }
+
+    @Test
+    fun testSeveralCompilerPluginsRequestedBySingleSnippetPersistAcrossSnippets() {
+        val engine = newEngine(withMainKtsOnCompileClasspath = true, withSerializationRuntime = true)
+        assertEquals(
+            null,
+            engine.eval(
+                """
+                    ${serializationPluginAnnotation()}
+                    ${allOpenPluginAnnotation()}
+                    import kotlinx.serialization.Serializable
+
+                    @Serializable
+                    class User(val name: String)
+                """.trimIndent()
+            )
+        )
+        // The all-open plugin makes serializable classes open, so they can be subclassed.
+        assertEquals(
+            null,
+            engine.eval(
+                """
+                    import kotlinx.serialization.Serializable
+
+                    class Admin(name: String) : User(name)
+
+                    @Serializable
+                    class Project(val name: String)
+
+                    class InternalProject(name: String) : Project(name)
+                """.trimIndent()
+            )
+        )
+
+        val descriptorNames = engine.eval(
+            "User.serializer().descriptor.serialName + \"|\" + Project.serializer().descriptor.serialName"
+        ).toString().split('|')
+        assertEquals(2, descriptorNames.size)
+        assertTrue(descriptorNames[0].endsWith(".User"))
+        assertTrue(descriptorNames[1].endsWith(".Project"))
+        assertEquals("a|b", engine.eval("Admin(\"a\").name + \"|\" + InternalProject(\"b\").name"))
+    }
+
+    @Test
+    fun testSerializationCompilerPluginConflictKeepsOriginalOptions() {
+        val engine = newEngine(withMainKtsOnCompileClasspath = true, withSerializationRuntime = true)
+        engine.eval(
+            """
+                ${serializationPluginAnnotation()}
+                import kotlinx.serialization.Serializable
+
+                @Serializable
+                data class User(val name: String)
+            """.trimIndent()
+        )
+
+        val conflict = assertFailsWith<ScriptException> {
+            engine.eval(
+                """
+                    ${serializationPluginAnnotation("disableIntrinsic=true")}
+                    import kotlinx.serialization.Serializable
+
+                    @Serializable
+                    data class Project(val name: String)
+                """.trimIndent()
+            )
+        }
+        assertContains(conflict.message.orEmpty(), "conflicting options for compiler plugin", ignoreCase = true)
+        assertTrue(engine.eval("User.serializer().descriptor.serialName").toString().endsWith(".User"))
+    }
+
+    @Test
+    fun testSerializationCompilerPluginIsNotCommittedAfterFailedBatch() {
+        val engine = newEngine(withMainKtsOnCompileClasspath = true, withSerializationRuntime = true)
+        assertFailsWith<ScriptException> {
+            engine.eval(
+                """
+                    ${serializationPluginAnnotation()}
+                    import kotlinx.serialization.Serializable
+
+                    @Serializable
+                    data class Broken(val name: String)
+                    unresolvedName
+                """.trimIndent()
+            )
+        }
+
+        val afterRollback = assertFailsWith<ScriptException> {
+            engine.eval(
+                """
+                    import kotlinx.serialization.Serializable
+
+                    @Serializable
+                    data class AfterFailure(val name: String)
+                    AfterFailure.serializer().descriptor.serialName
+                """.trimIndent()
+            )
+        }
+        assertContains(afterRollback.message.orEmpty(), "serializer", ignoreCase = true)
+    }
+
+    @Test
     @Disabled("Same-batch @file:Import snippet chaining is not supported yet (codegen of cross-snippet accesses)")
     fun testWithImport() {
         val engine = newEngine()
@@ -126,6 +278,32 @@
 // Absolute, since `@file:Import` paths are resolved relative to the (temporary) snippet source file.
 private val TEST_DATA_ROOT = File("libraries/tools/kotlin-main-kts-test/testData").absoluteFile.invariantSeparatorsPath
 
+private fun serializationPluginAnnotation(options: String? = null): String {
+    val optionArgument = options?.let { ", \"$it\"" }.orEmpty()
+    return """@file:CompilerPlugin("${serializationPluginClasspathForScript()}"$optionArgument)"""
+}
+
+private fun allOpenPluginAnnotation(): String {
+    val classpath = System.getProperty("kotlin.script.test.allopen.plugin.classpath")!!
+        .split(File.pathSeparator)
+        .joinToString(File.pathSeparator) { it.replace(File.separatorChar, '/') }
+    return """@file:CompilerPlugin("$classpath", "annotation=kotlinx.serialization.Serializable")"""
+}
+
+private fun serializationPluginClasspathForScript(): String =
+    System.getProperty("kotlin.script.test.kotlinx.serialization.plugin.classpath")!!
+        .split(File.pathSeparator)
+        .joinToString(File.pathSeparator) { it.replace(File.separatorChar, '/') }
+
+@Suppress("DEPRECATION_ERROR")
+private fun serializationRuntimeClasspath(): List<Path> =
+    internalScriptingRunSuspend {
+        CompoundDependenciesResolver(MavenDependenciesResolver())
+            .resolve("org.jetbrains.kotlinx:kotlinx-serialization-core:1.8.1")
+            .valueOrThrow()
+            .map(File::toPath)
+    }
+
 object DependsOnProbe {
     const val VALUE: String = "resolved"
 }
diff --git a/libraries/examples/scripting/jsr223-daemon/build.gradle.kts b/libraries/examples/scripting/jsr223-daemon/build.gradle.kts
index b0cddcb..e08e64b 100644
--- a/libraries/examples/scripting/jsr223-daemon/build.gradle.kts
+++ b/libraries/examples/scripting/jsr223-daemon/build.gradle.kts
@@ -28,11 +28,18 @@
 }
 
 val daemonCompilerClasspath = configurations.create("daemonCompilerClasspath")
+val kotlinxSerializationCompilerPluginClasspath = configurations.create("kotlinxSerializationCompilerPluginClasspath")
+val allOpenCompilerPluginClasspath = configurations.create("allOpenCompilerPluginClasspath")
 
 dependencies {
     add(daemonCompilerClasspath.name, project(":kotlin-compiler"))
     add(daemonCompilerClasspath.name, project(":kotlin-daemon"))
     add(daemonCompilerClasspath.name, project(":kotlin-scripting-compiler"))
+    add(kotlinxSerializationCompilerPluginClasspath.name, project(":kotlinx-serialization-compiler-plugin.embeddable")) {
+        isTransitive = false
+    }
+    add(allOpenCompilerPluginClasspath.name, project(":kotlin-allopen-compiler-plugin")) { isTransitive = false }
+    testImplementation(project(":kotlin-scripting-dependencies-maven"))
 }
 
 sourceSets {
@@ -51,8 +58,18 @@
         dependsOn(":dist")
         workingDir = rootDir
         val classpathProvider = project.provider { daemonCompilerClasspath.files.joinToString(File.pathSeparator) }
+        val serializationPluginClasspathFiles: FileCollection = kotlinxSerializationCompilerPluginClasspath
+        inputs.files(serializationPluginClasspathFiles)
+            .withPropertyName("kotlinxSerializationCompilerPluginClasspath")
+            .withNormalizer(ClasspathNormalizer::class)
+        val allOpenPluginClasspathFiles: FileCollection = allOpenCompilerPluginClasspath
+        inputs.files(allOpenPluginClasspathFiles)
+            .withPropertyName("allOpenCompilerPluginClasspath")
+            .withNormalizer(ClasspathNormalizer::class)
         doFirst {
             systemProperty("kotlinJsr223DaemonCompilerClasspath", classpathProvider.get())
+            systemProperty("kotlin.script.test.kotlinx.serialization.plugin.classpath", serializationPluginClasspathFiles.asPath)
+            systemProperty("kotlin.script.test.allopen.plugin.classpath", allOpenPluginClasspathFiles.asPath)
         }
     }
 }
diff --git a/libraries/examples/scripting/jsr223-daemon/src/org/jetbrains/kotlin/jsr223/daemon/DaemonReplCompiler.kt b/libraries/examples/scripting/jsr223-daemon/src/org/jetbrains/kotlin/jsr223/daemon/DaemonReplCompiler.kt
index 4e3e895..aee7143 100644
--- a/libraries/examples/scripting/jsr223-daemon/src/org/jetbrains/kotlin/jsr223/daemon/DaemonReplCompiler.kt
+++ b/libraries/examples/scripting/jsr223-daemon/src/org/jetbrains/kotlin/jsr223/daemon/DaemonReplCompiler.kt
@@ -16,11 +16,7 @@
 import org.jetbrains.kotlin.daemon.common.*
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.ScriptNames
-import org.jetbrains.kotlin.scripting.compiler.plugin.KOTLIN_SCRIPTING_PLUGIN_ID
-import org.jetbrains.kotlin.scripting.compiler.plugin.ReplSnippetConfigurationCodec
-import org.jetbrains.kotlin.scripting.compiler.plugin.ScriptTemplateWithClasspath
-import org.jetbrains.kotlin.scripting.compiler.plugin.scriptTemplateWithClasspath
-import org.jetbrains.kotlin.scripting.compiler.plugin.withRefinedFromSnippetClass
+import org.jetbrains.kotlin.scripting.compiler.plugin.*
 import java.io.File
 import java.io.Serializable
 import java.nio.file.Files
@@ -109,6 +105,7 @@
 
     private val priorOutputDirs = mutableListOf<File>()
     private val priorClassIds = mutableListOf<ClassId>()
+    private var plugins = StatelessReplCompilerPlugins.EMPTY
 
     private var scriptTemplateCache: Pair<Any, ScriptTemplateWithClasspath?>? = null
 
@@ -172,34 +169,66 @@
         }
 
         val batchIndex = snippetCounter++
-        val outputDir = File(workRoot, "snippet-batch-$batchIndex-out").also { it.mkdirs() }
+        var finalOutputDir = File(workRoot, "snippet-batch-$batchIndex-out").also { it.mkdirs() }
         val configurationFile = File(workRoot, "snippet-batch-$batchIndex-configuration.bin").also {
             ReplSnippetConfigurationCodec.writeTo(batchConfiguration, it)
         }
         val sourceDir = Files.createTempDirectory("jsr223-daemon-repl-snippet-src-").toFile()
         try {
             val scriptFiles = refinedSnippets.map { File(sourceDir, it.name).also { file -> file.writeText(it.snippet.text) } }
-            val arguments = buildBatchCompilerArguments(
-                scriptFiles, priorOutputDirs, priorClassIds, outputDir, configurationFile, batchConfiguration
-            )
 
-            messageCollector.clear()
-            val exitCode = runDaemonCompile(arguments)
+            fun compile(outputDir: File, pluginSet: StatelessReplCompilerPlugins): Int {
+                messageCollector.clear()
+                val arguments = buildBatchCompilerArguments(
+                    scriptFiles,
+                    priorOutputDirs,
+                    priorClassIds,
+                    outputDir,
+                    configurationFile,
+                    batchConfiguration,
+                    pluginSet,
+                )
+                return runDaemonCompile(arguments)
+            }
+
+            var candidatePlugins = plugins
+            var exitCode = compile(finalOutputDir, candidatePlugins)
+            // The compiler reports compiler plugins requested by the snippets, but not loaded yet, in a dedicated diagnostic.
+            val requestedPlugins = try {
+                messageCollector.messages.mapNotNull(StatelessReplPluginRequestsCodec::extractMissingPluginRequests)
+                    .takeIf { it.isNotEmpty() }?.flatten()
+            } catch (exception: Exception) {
+                return ResultWithDiagnostics.Failure(
+                    "DaemonReplCompiler: unable to decode compiler plugin requests: ${exception.message}".asErrorDiagnostics()
+                )
+            }
+            if (requestedPlugins != null) {
+                candidatePlugins = plugins.merge(requestedPlugins).valueOr { return it }
+
+                finalOutputDir = File(workRoot, "snippet-batch-$batchIndex-retry-out").also { it.mkdirs() }
+                exitCode = compile(finalOutputDir, candidatePlugins)
+                if (messageCollector.messages.any { StatelessReplPluginRequestsCodec.extractMissingPluginRequests(it) != null }) {
+                    return ResultWithDiagnostics.Failure(
+                        "DaemonReplCompiler: compiler requested plugins after its single retry".asErrorDiagnostics()
+                    )
+                }
+            }
+
             if (exitCode != ExitCode.OK.code) {
                 return ResultWithDiagnostics.Failure(
                     messageCollector.messages.map { it.asErrorDiagnostics(path = refinedSnippets.last().snippet.locationId) }
                 )
             }
 
-            priorOutputDirs += outputDir
+            priorOutputDirs += finalOutputDir
             for ([refinedSnippet, scriptFile] in refinedSnippets.zip(scriptFiles)) {
                 val classId = snippetClassId(scriptFile)
                 // Brings in compiler-side refinement results, e.g. `@DependsOn`-resolved jars.
                 val compilationConfiguration = refinedSnippet.configuration.withRefinedFromSnippetClass(
-                    File(outputDir, "${classId.shortClassName.asString()}.class")
+                    File(finalOutputDir, "${classId.shortClassName.asString()}.class")
                 )
                 val compiledSnippet = compiledSnippetFromClassPath(
-                    classPath = listOf(outputDir),
+                    classPath = listOf(finalOutputDir),
                     snippetClassFQName = classId.asSingleFqName().asString(),
                     snippet = refinedSnippet.snippet,
                     compilationConfiguration = compilationConfiguration,
@@ -207,6 +236,7 @@
                 priorClassIds += classId
                 lastCompiledSnippetInternal = lastCompiledSnippetInternal.add(compiledSnippet)
             }
+            plugins = candidatePlugins
             reports += messageCollector.messages.map {
                 ScriptDiagnostic(
                     ScriptDiagnostic.unspecifiedInfo, it, ScriptDiagnostic.Severity.WARNING,
@@ -226,6 +256,7 @@
         outputDir: File,
         configurationFile: File,
         batchConfiguration: ScriptCompilationConfiguration,
+        plugins: StatelessReplCompilerPlugins,
     ): List<String> {
         fun pluginOption(name: String, value: String) = "plugin:$KOTLIN_SCRIPTING_PLUGIN_ID:$name=$value"
         return buildList {
@@ -247,6 +278,10 @@
             }
             add("-P")
             add(pluginOption("repl-snippet-configuration", configurationFile.absolutePath))
+            plugins.loadedKeyOptions().forEach { loadedPlugin ->
+                add("-P")
+                add(pluginOption("repl-snippet-loaded-plugin", loadedPlugin))
+            }
             // Refinement handlers are transient and cannot travel in the configuration file, so the compiler
             // loads the definition from its template and overrides it with the configuration from the file.
             scriptTemplateWithClasspathOf(batchConfiguration)?.let { template ->
@@ -255,6 +290,7 @@
                 add("-P")
                 add(pluginOption("script-definitions-classpath", template.classpath.joinToString(File.pathSeparator) { it.path }))
             }
+            addAll(plugins.cliArguments())
             add("-d")
             add(outputDir.absolutePath)
             add("-Xsuppress-version-warnings")
diff --git a/libraries/examples/scripting/jsr223-daemon/test/org/jetbrains/kotlin/jsr223/daemon/test/KotlinJsr223DaemonScriptEngineMainKtsTest.kt b/libraries/examples/scripting/jsr223-daemon/test/org/jetbrains/kotlin/jsr223/daemon/test/KotlinJsr223DaemonScriptEngineMainKtsTest.kt
index d895cd7..ec68655 100644
--- a/libraries/examples/scripting/jsr223-daemon/test/org/jetbrains/kotlin/jsr223/daemon/test/KotlinJsr223DaemonScriptEngineMainKtsTest.kt
+++ b/libraries/examples/scripting/jsr223-daemon/test/org/jetbrains/kotlin/jsr223/daemon/test/KotlinJsr223DaemonScriptEngineMainKtsTest.kt
@@ -5,10 +5,10 @@
 
 package org.jetbrains.kotlin.jsr223.daemon.test
 
-import org.jetbrains.kotlin.jsr223.daemon.KotlinJsr223DaemonScriptEngineFactory
-import org.jetbrains.kotlin.jsr223.daemon.KotlinJsr223DaemonScriptEngineImpl
 import org.jetbrains.kotlin.daemon.common.DaemonLogOptions
 import org.jetbrains.kotlin.daemon.common.DaemonOptions
+import org.jetbrains.kotlin.jsr223.daemon.KotlinJsr223DaemonScriptEngineFactory
+import org.jetbrains.kotlin.jsr223.daemon.KotlinJsr223DaemonScriptEngineImpl
 import org.jetbrains.kotlin.mainKts.MainKtsScript
 import org.junit.jupiter.api.AfterEach
 import org.junit.jupiter.api.Assertions.assertEquals
@@ -20,8 +20,16 @@
 import java.nio.file.Path
 import java.util.jar.JarEntry
 import java.util.jar.JarOutputStream
+import javax.script.ScriptException
 import kotlin.io.path.invariantSeparatorsPathString
+import kotlin.script.experimental.api.valueOrThrow
+import kotlin.script.experimental.dependencies.CompoundDependenciesResolver
+import kotlin.script.experimental.dependencies.maven.MavenDependenciesResolver
+import kotlin.script.experimental.impl.internalScriptingRunSuspend
 import kotlin.script.experimental.jvmhost.createJvmScriptDefinitionFromTemplate
+import kotlin.test.assertContains
+import kotlin.test.assertFailsWith
+import kotlin.test.assertTrue
 
 /**
  * Ports a few jsr223-specific main-kts tests (see `MainKtsJsr223Test` in `kotlin-main-kts-test`) to
@@ -41,11 +49,18 @@
 
     private val dirsToDeleteAfterEngines = mutableListOf<Path>()
 
-    private fun newEngine(withMainKtsOnCompileClasspath: Boolean = false): KotlinJsr223DaemonScriptEngineImpl {
+    private fun newEngine(
+        withMainKtsOnCompileClasspath: Boolean = false,
+        withSerializationRuntime: Boolean = false,
+    ): KotlinJsr223DaemonScriptEngineImpl {
+        val additionalClasspath = buildList {
+            addAll(listOf(stdlibPath, scriptRuntimePath))
+            if (withSerializationRuntime) addAll(serializationRuntimeClasspath())
+            if (withMainKtsOnCompileClasspath) addAll(mainKtsPaths)
+        }
         val factory = KotlinJsr223DaemonScriptEngineFactory(
             compilerClasspath = compilerClasspath,
-            additionalClasspath = listOf(stdlibPath, scriptRuntimePath) +
-                    if (withMainKtsOnCompileClasspath) mainKtsPaths else emptyList(),
+            additionalClasspath = additionalClasspath,
             daemonOptions = DaemonOptions(
                 runFilesPath = daemonRunDir.resolve("run").toString(),
                 shutdownDelayMilliseconds = 0,
@@ -135,6 +150,142 @@
     }
 
     @Test
+    fun testSerializationCompilerPluginPersistsAcrossSnippets() {
+        val engine = newEngine(withMainKtsOnCompileClasspath = true, withSerializationRuntime = true)
+        assertEquals(
+            null,
+            engine.eval(
+                """
+                    ${serializationPluginAnnotation()}
+                    import kotlinx.serialization.Serializable
+
+                    @Serializable
+                    data class User(val name: String)
+                """.trimIndent()
+            )
+        )
+        assertEquals(
+            null,
+            engine.eval(
+                """
+                    ${serializationPluginAnnotation()}
+                    import kotlinx.serialization.Serializable
+
+                    @Serializable
+                    data class Project(val name: String)
+                """.trimIndent()
+            )
+        )
+
+        val descriptorNames = engine.eval(
+            "User.serializer().descriptor.serialName + \"|\" + Project.serializer().descriptor.serialName"
+        ).toString().split('|')
+        assertEquals(2, descriptorNames.size)
+        assertTrue(descriptorNames[0].endsWith(".User"))
+        assertTrue(descriptorNames[1].endsWith(".Project"))
+    }
+
+    @Test
+    fun testSeveralCompilerPluginsRequestedBySingleSnippetPersistAcrossSnippets() {
+        val engine = newEngine(withMainKtsOnCompileClasspath = true, withSerializationRuntime = true)
+        assertEquals(
+            null,
+            engine.eval(
+                """
+                    ${serializationPluginAnnotation()}
+                    ${allOpenPluginAnnotation()}
+                    import kotlinx.serialization.Serializable
+
+                    @Serializable
+                    class User(val name: String)
+                """.trimIndent()
+            )
+        )
+        // The all-open plugin makes serializable classes open, so they can be subclassed.
+        assertEquals(
+            null,
+            engine.eval(
+                """
+                    import kotlinx.serialization.Serializable
+
+                    class Admin(name: String) : User(name)
+
+                    @Serializable
+                    class Project(val name: String)
+
+                    class InternalProject(name: String) : Project(name)
+                """.trimIndent()
+            )
+        )
+
+        val descriptorNames = engine.eval(
+            "User.serializer().descriptor.serialName + \"|\" + Project.serializer().descriptor.serialName"
+        ).toString().split('|')
+        assertEquals(2, descriptorNames.size)
+        assertTrue(descriptorNames[0].endsWith(".User"))
+        assertTrue(descriptorNames[1].endsWith(".Project"))
+        assertEquals("a|b", engine.eval("Admin(\"a\").name + \"|\" + InternalProject(\"b\").name"))
+    }
+
+    @Test
+    fun testSerializationCompilerPluginConflictKeepsOriginalOptions() {
+        val engine = newEngine(withMainKtsOnCompileClasspath = true, withSerializationRuntime = true)
+        engine.eval(
+            """
+                ${serializationPluginAnnotation()}
+                import kotlinx.serialization.Serializable
+
+                @Serializable
+                data class User(val name: String)
+            """.trimIndent()
+        )
+
+        val conflict = assertFailsWith<ScriptException> {
+            engine.eval(
+                """
+                    ${serializationPluginAnnotation("disableIntrinsic=true")}
+                    import kotlinx.serialization.Serializable
+
+                    @Serializable
+                    data class Project(val name: String)
+                """.trimIndent()
+            )
+        }
+        assertContains(conflict.message.orEmpty(), "conflicting options for compiler plugin", ignoreCase = true)
+        assertTrue(engine.eval("User.serializer().descriptor.serialName").toString().endsWith(".User"))
+    }
+
+    @Test
+    fun testSerializationCompilerPluginIsNotCommittedAfterFailedBatch() {
+        val engine = newEngine(withMainKtsOnCompileClasspath = true, withSerializationRuntime = true)
+        assertFailsWith<ScriptException> {
+            engine.eval(
+                """
+                    ${serializationPluginAnnotation()}
+                    import kotlinx.serialization.Serializable
+
+                    @Serializable
+                    data class Broken(val name: String)
+                    unresolvedName
+                """.trimIndent()
+            )
+        }
+
+        val afterRollback = assertFailsWith<ScriptException> {
+            engine.eval(
+                """
+                    import kotlinx.serialization.Serializable
+
+                    @Serializable
+                    data class AfterFailure(val name: String)
+                    AfterFailure.serializer().descriptor.serialName
+                """.trimIndent()
+            )
+        }
+        assertContains(afterRollback.message.orEmpty(), "serializer", ignoreCase = true)
+    }
+
+    @Test
     @Disabled("Same-batch @file:Import snippet chaining is not supported yet (codegen of cross-snippet accesses)")
     fun testWithImport() {
         val engine = newEngine()
@@ -153,6 +304,32 @@
 // Absolute, since `@file:Import` paths are resolved relative to the (temporary) snippet source file.
 private val TEST_DATA_ROOT = File("libraries/tools/kotlin-main-kts-test/testData").absoluteFile.invariantSeparatorsPath
 
+private fun serializationPluginAnnotation(options: String? = null): String {
+    val optionArgument = options?.let { ", \"$it\"" }.orEmpty()
+    return """@file:CompilerPlugin("${serializationPluginClasspathForScript()}"$optionArgument)"""
+}
+
+private fun allOpenPluginAnnotation(): String {
+    val classpath = System.getProperty("kotlin.script.test.allopen.plugin.classpath")!!
+        .split(File.pathSeparator)
+        .joinToString(File.pathSeparator) { it.replace(File.separatorChar, '/') }
+    return """@file:CompilerPlugin("$classpath", "annotation=kotlinx.serialization.Serializable")"""
+}
+
+private fun serializationPluginClasspathForScript(): String =
+    System.getProperty("kotlin.script.test.kotlinx.serialization.plugin.classpath")!!
+        .split(File.pathSeparator)
+        .joinToString(File.pathSeparator) { it.replace(File.separatorChar, '/') }
+
+@Suppress("DEPRECATION_ERROR")
+private fun serializationRuntimeClasspath(): List<Path> =
+    internalScriptingRunSuspend {
+        CompoundDependenciesResolver(MavenDependenciesResolver())
+            .resolve("org.jetbrains.kotlinx:kotlinx-serialization-core:1.8.1")
+            .valueOrThrow()
+            .map(File::toPath)
+    }
+
 object DependsOnProbe {
     const val VALUE: String = "resolved"
 }
diff --git a/plugins/scripting/scripting-compiler-impl/src/org/jetbrains/kotlin/scripting/configuration/ScriptingConfigurationKeys.kt b/plugins/scripting/scripting-compiler-impl/src/org/jetbrains/kotlin/scripting/configuration/ScriptingConfigurationKeys.kt
index 2ce5317..89b2109 100644
--- a/plugins/scripting/scripting-compiler-impl/src/org/jetbrains/kotlin/scripting/configuration/ScriptingConfigurationKeys.kt
+++ b/plugins/scripting/scripting-compiler-impl/src/org/jetbrains/kotlin/scripting/configuration/ScriptingConfigurationKeys.kt
@@ -64,4 +64,8 @@
     // File with a serialized `ScriptCompilationConfiguration` for the snippets compilation
     val REPL_SNIPPET_CONFIGURATION_FILE: CompilerConfigurationKey<File> =
         CompilerConfigurationKey.create("REPL_SNIPPET_CONFIGURATION_FILE")
+
+    // Encoded compiler plugin requests already loaded by the stateless REPL host.
+    val REPL_SNIPPET_LOADED_PLUGINS: CompilerConfigurationKey<List<String>> =
+        CompilerConfigurationKey.create("REPL_SNIPPET_LOADED_PLUGINS")
 }
diff --git a/plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/FirScriptingCompilerExtensionRegistrar.kt b/plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/FirScriptingCompilerExtensionRegistrar.kt
index d393885..de35815 100644
--- a/plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/FirScriptingCompilerExtensionRegistrar.kt
+++ b/plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/FirScriptingCompilerExtensionRegistrar.kt
@@ -12,20 +12,10 @@
 import org.jetbrains.kotlin.fir.builder.FirReplSnippetConfiguratorExtension
 import org.jetbrains.kotlin.fir.extensions.FirExtensionRegistrar
 import org.jetbrains.kotlin.fir.extensions.FirExtensionSessionComponent
-import org.jetbrains.kotlin.fir.extensions.FirReplSnippetResolveExtension
-import org.jetbrains.kotlin.scripting.compiler.plugin.services.ClasspathBackedFirReplHistoryProvider
-import org.jetbrains.kotlin.scripting.compiler.plugin.services.Fir2IrReplSnippetConfiguratorExtensionImpl
-import org.jetbrains.kotlin.scripting.compiler.plugin.services.Fir2IrScriptConfiguratorExtensionImpl
-import org.jetbrains.kotlin.scripting.compiler.plugin.services.FirReplSnippetConfiguratorExtensionImpl
-import org.jetbrains.kotlin.scripting.compiler.plugin.services.FirReplSnippetResolveExtensionImpl
-import org.jetbrains.kotlin.scripting.compiler.plugin.services.FirScriptConfiguratorExtensionImpl
-import org.jetbrains.kotlin.scripting.compiler.plugin.services.FirScriptDefinitionProviderService
-import org.jetbrains.kotlin.scripting.compiler.plugin.services.FirScriptResolutionConfigurationExtensionImpl
-import org.jetbrains.kotlin.scripting.compiler.plugin.services.firReplHistoryProvider
-import org.jetbrains.kotlin.scripting.compiler.plugin.services.isReplSnippetSource
-import org.jetbrains.kotlin.scripting.configuration.ScriptingConfigurationKeys
+import org.jetbrains.kotlin.scripting.compiler.plugin.impl.StatelessReplPluginRequestReporter
 import org.jetbrains.kotlin.scripting.compiler.plugin.impl.isSnippetDefinition
-import org.jetbrains.kotlin.scripting.compiler.plugin.services.scriptDefinitionProviderService
+import org.jetbrains.kotlin.scripting.compiler.plugin.services.*
+import org.jetbrains.kotlin.scripting.configuration.ScriptingConfigurationKeys
 import org.jetbrains.kotlin.scripting.resolve.toSourceCode
 import kotlin.script.experimental.api.ScriptCompilationConfiguration
 import kotlin.script.experimental.api.repl
@@ -46,6 +36,7 @@
         +Fir2IrScriptConfiguratorExtensionImpl.getFactory()
 
         if (compilerConfiguration.getBoolean(ScriptingConfigurationKeys.REPL_SNIPPET_STATELESS_MODE)) {
+            val pluginRequestReporter = StatelessReplPluginRequestReporter(compilerConfiguration)
             val priorClassIds = compilerConfiguration.getList(ScriptingConfigurationKeys.REPL_SNIPPET_PRIOR_CLASSES)
             var capturedSession: FirSession? = null
             val historyProvider = ClasspathBackedFirReplHistoryProvider(priorClassIds) { capturedSession }
@@ -64,7 +55,7 @@
             }
             +FirReplSnippetConfiguratorExtension.Factory { session ->
                 capturedSession = session
-                FirReplSnippetConfiguratorExtensionImpl(session, replHostConfiguration)
+                FirReplSnippetConfiguratorExtensionImpl(session, replHostConfiguration, pluginRequestReporter)
             }
             +FirExtensionSessionComponent.Factory { session ->
                 capturedSession = session
diff --git a/plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/ScriptingCommandLineProcessor.kt b/plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/ScriptingCommandLineProcessor.kt
index 93d563d..d24397f 100644
--- a/plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/ScriptingCommandLineProcessor.kt
+++ b/plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/ScriptingCommandLineProcessor.kt
@@ -91,6 +91,11 @@
             "Path to a file with a serialized ScriptCompilationConfiguration for the snippets compilation",
             required = false, allowMultipleOccurrences = false
         )
+        val REPL_SNIPPET_LOADED_PLUGIN_OPTION = CliOption(
+            "repl-snippet-loaded-plugin", "<encoded plugin request>",
+            "Compiler plugin request already loaded by the stateless REPL host; repeat for each plugin",
+            required = false, allowMultipleOccurrences = true
+        )
     }
 
     override val pluginId = KOTLIN_SCRIPTING_PLUGIN_ID
@@ -110,6 +115,7 @@
             REPL_SNIPPET_PRIOR_CLASS_OPTION,
             REPL_SNIPPET_STATELESS_MODE_OPTION,
             REPL_SNIPPET_CONFIGURATION_OPTION,
+            REPL_SNIPPET_LOADED_PLUGIN_OPTION,
         )
 
     override fun processOption(option: AbstractCliOption, value: String, configuration: CompilerConfiguration) = when (option) {
@@ -195,6 +201,9 @@
         REPL_SNIPPET_CONFIGURATION_OPTION -> {
             configuration.put(ScriptingConfigurationKeys.REPL_SNIPPET_CONFIGURATION_FILE, File(value))
         }
+        REPL_SNIPPET_LOADED_PLUGIN_OPTION -> {
+            configuration.add(ScriptingConfigurationKeys.REPL_SNIPPET_LOADED_PLUGINS, value)
+        }
         else -> throw CliOptionProcessingException("Unknown option: ${option.optionName}")
     }
 }
diff --git a/plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/StatelessReplCompilerPlugins.kt b/plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/StatelessReplCompilerPlugins.kt
new file mode 100644
index 0000000..4514abc
--- /dev/null
+++ b/plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/StatelessReplCompilerPlugins.kt
@@ -0,0 +1,74 @@
+/*
+ * Copyright 2010-2026 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.scripting.compiler.plugin
+
+import java.io.File
+import kotlin.script.experimental.api.ResultWithDiagnostics
+import kotlin.script.experimental.api.asErrorDiagnostics
+
+class StatelessReplCompilerPlugins private constructor(
+    private val byKey: Map<String, StatelessReplPluginRequest>,
+) {
+    fun merge(requests: List<StatelessReplPluginRequest>): ResultWithDiagnostics<StatelessReplCompilerPlugins> {
+        val merged = LinkedHashMap(byKey)
+        for (request in requests) {
+            val sameKey = merged[request.key]
+            if (sameKey != null) {
+                if (sameKey.pluginId != request.pluginId || sameKey.options != request.options) {
+                    return conflict(sameKey.description())
+                }
+                continue
+            }
+
+            val samePlugin = merged.values.firstOrNull { it.pluginId == request.pluginId }
+            if (samePlugin != null) {
+                if (samePlugin.options != request.options) return conflict(request.pluginId)
+                continue
+            }
+
+            merged[request.key] = request
+        }
+        return ResultWithDiagnostics.Success(StatelessReplCompilerPlugins(merged))
+    }
+
+    fun cliArguments(): List<String> = buildList {
+        byKey.values.flatMap { it.classpath }.distinct().forEach { classpath ->
+            add("-Xplugin=${classpath.path}")
+        }
+        byKey.values.forEach { [_, pluginId, _, options] ->
+            options.forEach { option ->
+                val optionSeparator = option.indexOf('=')
+                require(optionSeparator > 0) { "Invalid compiler plugin option '$option'." }
+                val optionName = option.substring(0, optionSeparator)
+                val optionValue = option.substring(optionSeparator + 1)
+                add("-P")
+                add("plugin:$pluginId:$optionName=$optionValue")
+            }
+        }
+    }
+
+    fun loadedKeys(): List<String> = byKey.keys.toList()
+
+    fun entries(): List<StatelessReplPluginRequest> = byKey.values.toList()
+
+    fun loadedKeyOptions(): List<String> = byKey.values.map { [key, pluginId, _, options] ->
+        StatelessReplPluginRequestsCodec.encodeLoadedPluginOption(key, pluginId, options)
+    }
+
+    private fun StatelessReplPluginRequest.description(): String {
+        val classpathKey = classpath.joinToString(File.pathSeparator) { it.absoluteFile.normalize().path }
+        return if (key == classpathKey) classpath.joinToString(",") { it.path } else key
+    }
+
+    private fun conflict(pluginDescription: String): ResultWithDiagnostics.Failure =
+        ResultWithDiagnostics.Failure(
+            "Conflicting options for compiler plugin '$pluginDescription'.".asErrorDiagnostics()
+        )
+
+    companion object {
+        val EMPTY = StatelessReplCompilerPlugins(emptyMap())
+    }
+}
diff --git a/plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/StatelessReplPluginRequests.kt b/plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/StatelessReplPluginRequests.kt
new file mode 100644
index 0000000..15173d9
--- /dev/null
+++ b/plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/StatelessReplPluginRequests.kt
@@ -0,0 +1,91 @@
+/*
+ * Copyright 2010-2026 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.scripting.compiler.plugin
+
+import java.io.*
+import java.util.*
+
+data class StatelessReplPluginRequest(
+    val key: String,
+    val pluginId: String,
+    val classpath: List<File>,
+    val options: List<String>,
+)
+
+data class StatelessReplLoadedPlugin(
+    val key: String,
+    val pluginId: String,
+    val options: List<String>,
+)
+
+object StatelessReplPluginRequestsCodec {
+    private const val MAX_ENTRIES = 10_000
+    private const val MISSING_PLUGIN_HEADER = "Compilation requires compiler plugin "
+    private const val PLUGIN_CLASSPATH_PREFIX = "-Xplugin="
+    private const val PLUGIN_OPTION_PREFIX = "-P plugin:"
+    private val missingPluginHeaderRegex = Regex("${Regex.escape(MISSING_PLUGIN_HEADER)}'(.+)' \\(id '([^']+)'\\):")
+
+    /**
+     * Renders the error diagnostic reported by a stateless snippet compilation for a requested compiler plugin
+     * that is not loaded yet. The header names the request and the plugin id, and it is followed by the legacy
+     * CLI plugin arguments (`-Xplugin=<jar>` and `-P plugin:<id>:<option>`) needed to load the plugin, one per line,
+     * so the host can extract the request with [extractMissingPluginRequests] and retry the compilation.
+     */
+    fun missingPluginMessage(request: StatelessReplPluginRequest): String = buildString {
+        append("$MISSING_PLUGIN_HEADER'${request.key}' (id '${request.pluginId}'):")
+        request.classpath.forEach { append("\n  $PLUGIN_CLASSPATH_PREFIX${it.path}") }
+        request.options.forEach { append("\n  $PLUGIN_OPTION_PREFIX${request.pluginId}:$it") }
+    }
+
+    /**
+     * Extracts the requests from all diagnostics rendered by [missingPluginMessage] found in [message],
+     * or returns `null` if the message contains no such diagnostic.
+     */
+    fun extractMissingPluginRequests(message: String): List<StatelessReplPluginRequest>? {
+        val requests = mutableListOf<StatelessReplPluginRequest>()
+        val lines = message.lines()
+        var index = 0
+        while (index < lines.size) {
+            val header = missingPluginHeaderRegex.find(lines[index++]) ?: continue
+            val key = header.groupValues[1]
+            val pluginId = header.groupValues[2]
+            val optionPrefix = "$PLUGIN_OPTION_PREFIX$pluginId:"
+            val classpath = mutableListOf<File>()
+            val options = mutableListOf<String>()
+            while (index < lines.size) {
+                val line = lines[index].trim()
+                when {
+                    line.startsWith(PLUGIN_CLASSPATH_PREFIX) -> classpath += File(line.removePrefix(PLUGIN_CLASSPATH_PREFIX))
+                    line.startsWith(optionPrefix) -> options += line.removePrefix(optionPrefix)
+                    else -> break
+                }
+                index++
+            }
+            require(classpath.isNotEmpty()) { "No classpath specified for the requested compiler plugin '$key'" }
+            requests += StatelessReplPluginRequest(key, pluginId, classpath, options)
+        }
+        return requests.takeIf { it.isNotEmpty() }
+    }
+
+    fun encodeLoadedPluginOption(key: String, pluginId: String, options: List<String>): String {
+        val bytes = ByteArrayOutputStream()
+        DataOutputStream(bytes).use { output ->
+            output.writeUTF(key)
+            output.writeUTF(pluginId)
+            output.writeInt(options.size)
+            options.forEach(output::writeUTF)
+        }
+        return Base64.getUrlEncoder().withoutPadding().encodeToString(bytes.toByteArray())
+    }
+
+    fun decodeLoadedPluginOption(value: String): StatelessReplLoadedPlugin =
+        DataInputStream(Base64.getUrlDecoder().decode(value).inputStream()).use { input ->
+            val key = input.readUTF()
+            val pluginId = input.readUTF()
+            val count = input.readInt().also { require(it in 0..MAX_ENTRIES) { "Invalid loaded plugin option count: $it" } }
+            StatelessReplLoadedPlugin(key, pluginId, List(count) { input.readUTF() })
+        }
+}
diff --git a/plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/impl/StatelessReplPluginRequestReporter.kt b/plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/impl/StatelessReplPluginRequestReporter.kt
new file mode 100644
index 0000000..19a38d4
--- /dev/null
+++ b/plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/impl/StatelessReplPluginRequestReporter.kt
@@ -0,0 +1,116 @@
+/*
+ * Copyright 2010-2026 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.scripting.compiler.plugin.impl
+
+import com.intellij.openapi.util.Disposer
+import org.jetbrains.kotlin.cli.common.kotlinPaths
+import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
+import org.jetbrains.kotlin.cli.common.messages.MessageCollector
+import org.jetbrains.kotlin.compiler.plugin.CompilerPluginRegistrar
+import org.jetbrains.kotlin.config.CompilerConfiguration
+import org.jetbrains.kotlin.config.MessageCollectorAccess
+import org.jetbrains.kotlin.config.messageCollector
+import org.jetbrains.kotlin.scripting.compiler.plugin.ReplSnippetConfigurationCodec
+import org.jetbrains.kotlin.scripting.compiler.plugin.StatelessReplLoadedPlugin
+import org.jetbrains.kotlin.scripting.compiler.plugin.StatelessReplPluginRequest
+import org.jetbrains.kotlin.scripting.compiler.plugin.StatelessReplPluginRequestsCodec
+import org.jetbrains.kotlin.scripting.configuration.ScriptingConfigurationKeys
+import kotlin.script.experimental.api.ScriptCompilationConfiguration
+import kotlin.script.experimental.api.ScriptCompilerPlugin
+import kotlin.script.experimental.api.compilerOptions
+
+@OptIn(MessageCollectorAccess::class)
+class StatelessReplPluginRequestReporter(private val compilerConfiguration: CompilerConfiguration) {
+    private val messageCollector: MessageCollector = compilerConfiguration.messageCollector
+    private val baseCompilerOptions = compilerConfiguration[ScriptingConfigurationKeys.REPL_SNIPPET_CONFIGURATION_FILE]
+        ?.let(ReplSnippetConfigurationCodec::readFrom)
+        ?.get(ScriptCompilationConfiguration.compilerOptions).orEmpty()
+    private val loadedPlugins = compilerConfiguration.getList(ScriptingConfigurationKeys.REPL_SNIPPET_LOADED_PLUGINS)
+        .mapNotNull { encoded ->
+            runCatching { StatelessReplPluginRequestsCodec.decodeLoadedPluginOption(encoded) }
+                .onFailure {
+                    messageCollector.report(
+                        CompilerMessageSeverity.ERROR,
+                        "Invalid loaded REPL compiler plugin request: ${it.message}"
+                    )
+                }
+                .getOrNull()
+        }
+        .associateBy(StatelessReplLoadedPlugin::key)
+    private val globalPluginIds = compilerConfiguration.getList(CompilerPluginRegistrar.COMPILER_PLUGIN_REGISTRARS)
+        .mapTo(mutableSetOf()) { it.pluginId }
+    private val requests = linkedMapOf<String, StatelessReplPluginRequest>()
+
+    fun report(source: kotlin.script.experimental.api.SourceCode, refinedConfiguration: ScriptCompilationConfiguration) {
+        val plugins = collectScriptCompilerPlugins(
+            baseCompilerOptions,
+            listOf(source),
+            { refinedConfiguration },
+            messageCollector,
+        )
+
+        val newRequests = mutableListOf<StatelessReplPluginRequest>()
+        for (plugin in plugins) {
+            val key = plugin.requestKey
+            val loadedOptions = loadedPlugins[key]
+            if (loadedOptions != null) {
+                if (loadedOptions.pluginId !in globalPluginIds) {
+                    messageCollector.report(
+                        CompilerMessageSeverity.ERROR,
+                        "Stateless REPL compiler plugin '${loadedOptions.pluginId}' was marked loaded but is not registered."
+                    )
+                } else if (loadedOptions.options != plugin.options) {
+                    reportConflict(plugin.descriptionForDiagnostic())
+                }
+                continue
+            }
+
+            val previous = requests[key]
+            if (previous != null) {
+                if (previous.options != plugin.options) reportConflict(plugin.descriptionForDiagnostic())
+                continue
+            }
+
+            val classpath = validateAndResolveScriptCompilerPlugin(
+                plugin,
+                compilerConfiguration.kotlinPaths,
+                globalPluginIds,
+                messageCollector,
+            ) ?: continue
+            if (classpath.isEmpty()) continue
+
+            val registrarCount = compilerConfiguration.getList(CompilerPluginRegistrar.COMPILER_PLUGIN_REGISTRARS).size
+            val disposable = Disposer.newDisposable("stateless REPL compiler plugin validation")
+            val pluginId = try {
+                val validatedConfiguration = compilerConfiguration.copy()
+                    .withScriptCompilerPlugins(listOf(plugin), disposable, messageCollector)
+                    ?: continue
+                validatedConfiguration.getList(CompilerPluginRegistrar.COMPILER_PLUGIN_REGISTRARS)
+                    .drop(registrarCount)
+                    .singleOrNull()
+                    ?.pluginId
+                    ?: continue
+            } finally {
+                Disposer.dispose(disposable)
+            }
+
+            val request = StatelessReplPluginRequest(key, pluginId, classpath, plugin.options)
+            requests[key] = request
+            newRequests += request
+        }
+
+        // The host extracts the requests from these diagnostics, so that it can retry the compilation with the plugins loaded.
+        newRequests.forEach { request ->
+            messageCollector.report(CompilerMessageSeverity.ERROR, StatelessReplPluginRequestsCodec.missingPluginMessage(request))
+        }
+    }
+
+    private fun reportConflict(description: String) {
+        messageCollector.report(CompilerMessageSeverity.ERROR, "Conflicting options for compiler plugin '$description'.")
+    }
+
+    private fun ScriptCompilerPlugin.descriptionForDiagnostic(): String = id ?: classpath.joinToString(",")
+}
diff --git a/plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/impl/scriptCompilerPlugins.kt b/plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/impl/scriptCompilerPlugins.kt
index 703a235..43fd73f 100644
--- a/plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/impl/scriptCompilerPlugins.kt
+++ b/plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/impl/scriptCompilerPlugins.kt
@@ -21,11 +21,7 @@
 import org.jetbrains.kotlin.extensions.ProjectExtensionDescriptor
 import org.jetbrains.kotlin.utils.KotlinPaths
 import java.io.File
-import kotlin.script.experimental.api.ScriptCompilationConfiguration
-import kotlin.script.experimental.api.ScriptCompilerPlugin
-import kotlin.script.experimental.api.SourceCode
-import kotlin.script.experimental.api.compilerOptions
-import kotlin.script.experimental.api.compilerPlugins
+import kotlin.script.experimental.api.*
 
 // Short ids are limited to KotlinPaths.Jar entries.
 // Compose requires runtime setup; Parcelize is Android-specific; Atomicfu needs a runtime transformation.
@@ -163,20 +159,9 @@
     val pluginsByRegistrar = LinkedHashMap<CompilerPluginRegistrar, ScriptCompilerPlugin>()
 
     for (plugin in pluginsToLoad) {
-        val distJar = plugin.id?.let { id ->
-            scriptCompilerPluginDistributionJar(id) ?: return reportError("Unknown compiler plugin id '$id'.")
-        }
-        val classpath = if (distJar != null) {
-            val paths = kotlinPaths
-                ?: return reportError("Compiler plugin id '${plugin.id}' cannot be resolved by this host. Use a jar path instead.")
-            listOf(paths.jar(distJar))
-        } else {
-            plugin.classpath
-        }.map { it.absoluteFile.normalize() }
-
-        for (jar in classpath) {
-            if (!jar.isFile) return reportError("Compiler plugin jar '$jar' does not exist or is not a file.")
-        }
+        val classpath = validateAndResolveScriptCompilerPlugin(plugin, kotlinPaths, globalPluginIds, messageCollector)
+            ?: return null
+        if (classpath.isEmpty()) continue
 
         val classpathArgument = classpath.joinToString(",") { it.path }
         val pluginOptions = plugin.options
@@ -269,9 +254,44 @@
     return derivedConfiguration
 }
 
-private val ScriptCompilerPlugin.requestKey: String
+internal val ScriptCompilerPlugin.requestKey: String
     get() = id ?: classpath.joinToString(File.pathSeparator) { it.absoluteFile.normalize().path }
 
+internal fun validateAndResolveScriptCompilerPlugin(
+    plugin: ScriptCompilerPlugin,
+    kotlinPaths: KotlinPaths?,
+    globalPluginIds: Set<String>,
+    messageCollector: MessageCollector,
+): List<File>? {
+    fun reportError(message: String): List<File>? {
+        messageCollector.report(CompilerMessageSeverity.ERROR, message)
+        return null
+    }
+
+    if (plugin.id != null && plugin.id in globalPluginIds) {
+        if (plugin.options.isNotEmpty()) {
+            return reportError("Compiler plugin '${plugin.id}' is already loaded globally and cannot be configured from a script.")
+        }
+        return emptyList()
+    }
+
+    val distJar = plugin.id?.let { id ->
+        scriptCompilerPluginDistributionJar(id) ?: return reportError("Unknown compiler plugin id '$id'.")
+    }
+    val classpath = if (distJar != null) {
+        val paths = kotlinPaths
+            ?: return reportError("Compiler plugin id '${plugin.id}' cannot be resolved by this host. Use a jar path instead.")
+        listOf(paths.jar(distJar))
+    } else {
+        plugin.classpath
+    }.map { it.absoluteFile.normalize() }
+
+    for (jar in classpath) {
+        if (!jar.isFile) return reportError("Compiler plugin jar '$jar' does not exist or is not a file.")
+    }
+    return classpath
+}
+
 private val ScriptCompilerPlugin.description: String
     get() = id ?: classpath.joinToString(",")
 
diff --git a/plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/services/FirReplSnippetConfiguratorExtensionImpl.kt b/plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/services/FirReplSnippetConfiguratorExtensionImpl.kt
index f6584fa..b6622ea 100644
--- a/plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/services/FirReplSnippetConfiguratorExtensionImpl.kt
+++ b/plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/services/FirReplSnippetConfiguratorExtensionImpl.kt
@@ -5,7 +5,9 @@
 
 package org.jetbrains.kotlin.scripting.compiler.plugin.services
 
-import org.jetbrains.kotlin.*
+import org.jetbrains.kotlin.KtFakeSourceElementKind
+import org.jetbrains.kotlin.KtSourceElement
+import org.jetbrains.kotlin.KtSourceFile
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.fir.*
@@ -38,7 +40,9 @@
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.scripting.compiler.plugin.impl.StatelessReplPluginRequestReporter
 import org.jetbrains.kotlin.scripting.compiler.plugin.impl.currentSnippetNo
+import org.jetbrains.kotlin.scripting.resolve.toSourceCode
 import kotlin.contracts.ExperimentalContracts
 import kotlin.contracts.contract
 import kotlin.script.experimental.api.*
@@ -58,6 +62,7 @@
 class FirReplSnippetConfiguratorExtensionImpl(
     session: FirSession,
     private val hostConfiguration: ScriptingHostConfiguration,
+    private val pluginRequestReporter: StatelessReplPluginRequestReporter? = null,
 ) : FirReplSnippetConfiguratorExtension(session) {
 
     override fun isReplSnippetsSource(sourceFile: KtSourceFile?, scriptSource: KtSourceElement): Boolean =
@@ -72,6 +77,8 @@
             return
         }
 
+        pluginRequestReporter?.report(sourceFile.toSourceCode(), configuration)
+
         configuration[ScriptCompilationConfiguration.implicitReceivers]?.forEachIndexed { index, implicitReceiver ->
             receivers.add(
                 buildScriptReceiverParameter {
@@ -262,6 +269,13 @@
         fun getFactory(hostConfiguration: ScriptingHostConfiguration): Factory {
             return Factory { session -> FirReplSnippetConfiguratorExtensionImpl(session, hostConfiguration) }
         }
+
+        fun getFactory(
+            hostConfiguration: ScriptingHostConfiguration,
+            pluginRequestReporter: StatelessReplPluginRequestReporter,
+        ): Factory {
+            return Factory { session -> FirReplSnippetConfiguratorExtensionImpl(session, hostConfiguration, pluginRequestReporter) }
+        }
     }
 }
 
diff --git a/plugins/scripting/scripting-tests/build.gradle.kts b/plugins/scripting/scripting-tests/build.gradle.kts
index dcec92a..417619e 100644
--- a/plugins/scripting/scripting-tests/build.gradle.kts
+++ b/plugins/scripting/scripting-tests/build.gradle.kts
@@ -6,6 +6,7 @@
 }
 
 val powerAssertCompilerPluginJar = configurations.create("powerAssertCompilerPluginJar")
+val allOpenCompilerPluginClasspath = configurations.create("allOpenCompilerPluginClasspath")
 val kotlinxSerializationGradlePluginClasspath = configurations.create("kotlinxSerializationGradlePluginClasspath")
 val kotlinDataFrameGradlePluginClasspath = configurations.create("kotlinDataFrameGradlePluginClasspath")
 val kotlinxCoroutinesCoreGradlePluginClasspath = configurations.create("kotlinxCoroutinesCoreGradlePluginClasspath")
@@ -34,6 +35,7 @@
     testRuntimeOnly(project(":compiler:fir:plugin.api"))
 
     powerAssertCompilerPluginJar(project(":kotlin-power-assert-compiler-plugin")) { isTransitive = false }
+    allOpenCompilerPluginClasspath(project(":kotlin-allopen-compiler-plugin")) { isTransitive = false }
     kotlinxSerializationGradlePluginClasspath(project(":kotlinx-serialization-compiler-plugin.embeddable")) { isTransitive = true }
     kotlinDataFrameGradlePluginClasspath(project(":kotlin-dataframe-compiler-plugin.embeddable")) { isTransitive = true }
     kotlinxCoroutinesCoreGradlePluginClasspath(libs.kotlinx.coroutines.core) { isTransitive = false }
@@ -60,6 +62,7 @@
         workingDir = rootDir
         addClasspathProperty(testSourceSet.output.classesDirs, "kotlin.test.script.classpath")
         addClasspathProperty(powerAssertCompilerPluginJar, "kotlin.power.assert.compiler.plugin.jar")
+        addClasspathProperty(allOpenCompilerPluginClasspath, "kotlin.script.test.allopen.plugin.classpath")
         addClasspathProperty(kotlinxSerializationGradlePluginClasspath, "kotlin.script.test.kotlinx.serialization.plugin.classpath")
         addClasspathProperty(kotlinDataFrameGradlePluginClasspath, "kotlin.script.test.kotlin.dataframe.plugin.classpath")
         addClasspathProperty(kotlinxCoroutinesCoreGradlePluginClasspath, "kotlin.script.test.kotlinx.coroutines.core.classpath")
diff --git a/plugins/scripting/scripting-tests/tests/org/jetbrains/kotlin/scripting/test/repl/ReplSnippetStatelessCompilationTest.kt b/plugins/scripting/scripting-tests/tests/org/jetbrains/kotlin/scripting/test/repl/ReplSnippetStatelessCompilationTest.kt
index a129073..086a2b9 100644
--- a/plugins/scripting/scripting-tests/tests/org/jetbrains/kotlin/scripting/test/repl/ReplSnippetStatelessCompilationTest.kt
+++ b/plugins/scripting/scripting-tests/tests/org/jetbrains/kotlin/scripting/test/repl/ReplSnippetStatelessCompilationTest.kt
@@ -5,24 +5,23 @@
 
 package org.jetbrains.kotlin.scripting.compiler.test
 
+import kotlinx.coroutines.runBlocking
 import org.jetbrains.kotlin.cli.common.ExitCode
 import org.jetbrains.kotlin.cli.common.arguments.CommonCompilerArguments
 import org.jetbrains.kotlin.cli.common.arguments.K2JVMCompilerArguments
 import org.jetbrains.kotlin.cli.common.arguments.cliArgument
+import org.jetbrains.kotlin.cli.common.arguments.parseCommandLineArguments
+import org.jetbrains.kotlin.cli.common.messages.MessageCollectorImpl
+import org.jetbrains.kotlin.cli.jvm.K2JVMCompiler
 import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime
+import org.jetbrains.kotlin.config.Services
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.ScriptNames
-import org.jetbrains.kotlin.scripting.compiler.plugin.KOTLIN_SCRIPTING_PLUGIN_ID
-import org.jetbrains.kotlin.scripting.compiler.plugin.ReplSnippetConfigurationCodec
-import org.jetbrains.kotlin.scripting.compiler.plugin.impl.SCRIPT_BASE_COMPILER_ARGUMENTS_PROPERTY
-import org.jetbrains.kotlin.scripting.compiler.plugin.impl.SnippetArtifactMetadata
-import org.jetbrains.kotlin.scripting.compiler.plugin.impl.SnippetArtifactMetadataCodec
-import org.jetbrains.kotlin.scripting.compiler.plugin.impl.readRefinedCompilationConfiguration
-import org.jetbrains.kotlin.scripting.compiler.plugin.impl.readSnippetArtifactMetadata
-import org.jetbrains.kotlin.scripting.compiler.plugin.withRefinedFromCompiler
-import org.jetbrains.kotlin.scripting.compiler.test.TestScriptWithRequire
+import org.jetbrains.kotlin.scripting.compiler.plugin.*
+import org.jetbrains.kotlin.scripting.compiler.plugin.impl.*
 import org.jetbrains.kotlin.scripting.test.SCRIPT_TEST_BASE_COMPILER_ARGUMENTS_PROPERTY
+import org.jetbrains.kotlin.scripting.test.getBaseCompilerArgumentsFromProperty
 import org.jetbrains.kotlin.scripting.test.runWithK2JVMCompiler
 import org.jetbrains.kotlin.scripting.test.withTempDir
 import org.jetbrains.kotlin.utils.PathUtil
@@ -31,6 +30,8 @@
 import java.nio.file.Files
 import kotlin.reflect.KClass
 import kotlin.script.experimental.api.*
+import kotlin.script.experimental.dependencies.CompoundDependenciesResolver
+import kotlin.script.experimental.dependencies.maven.MavenDependenciesResolver
 import kotlin.script.experimental.host.createCompilationConfigurationFromTemplate
 import kotlin.script.experimental.impl.internalScriptingRunSuspend
 import kotlin.script.experimental.jvm.JvmDependency
@@ -81,6 +82,166 @@
     }
 
     @Test
+    fun testStatelessReplReportsAndLoadsRequestedCompilerPlugin() {
+        if (!isK2) return
+
+        withTempDir { workRoot ->
+            val pluginArguments = serializationPluginClasspath().map { "-Xplugin=${it.absolutePath}" }
+            val plainCompiler = StatelessReplCompiler(
+                workRoot = workRoot,
+                compilerPluginArguments = pluginArguments,
+                additionalClasspath = serializationRuntimeClasspath(),
+            )
+            plainCompiler.compile(
+                "import kotlinx.serialization.Serializable\n@Serializable data class User(val name: String)",
+                "plain-serialization.kts",
+            )
+            val serializerClassSuffix = buildString {
+                append("User")
+                repeat(2) { append('$') }
+                append("serializer.class")
+            }
+            assertTrue(plainCompiler.lastOutputDir.classFileNames().any { it.endsWith(serializerClassSuffix) })
+
+            val source = """
+                import kotlinx.serialization.Serializable
+
+                @Serializable
+                data class User(val name: String)
+            """.trimIndent()
+            val firstCompiler = StatelessReplCompiler(
+                workRoot = workRoot,
+                snippetConfiguration = serializationPluginConfiguration(),
+                additionalClasspath = serializationRuntimeClasspath(),
+            )
+            val errors = firstCompiler.compileCollectingErrors(source, "plugin-request.repl.kts")
+            val missingPluginsErrors = errors.filter { it.startsWith("Compilation requires compiler plugin ") }
+            assertEquals(1, missingPluginsErrors.size, "Expected a single missing plugins diagnostic, got: $errors")
+
+            val [requestKey, requestPluginId, requestClasspath, requestOptions] =
+                assertNotNull(StatelessReplPluginRequestsCodec.extractMissingPluginRequests(missingPluginsErrors.single())).single()
+            assertEquals(serializationPluginRequestKey(), requestKey)
+            assertTrue(requestClasspath.single().isFile)
+            assertTrue(requestOptions.isEmpty())
+
+            val forwardedPluginArguments = requestClasspath.map { "-Xplugin=${it.absolutePath}" }
+            val forwardedCompiler = StatelessReplCompiler(
+                workRoot = workRoot,
+                snippetConfiguration = serializationPluginConfiguration(),
+                loadedPlugins = listOf(StatelessReplLoadedPlugin(requestKey, requestPluginId, requestOptions)),
+                compilerPluginArguments = forwardedPluginArguments,
+                additionalClasspath = serializationRuntimeClasspath(),
+            )
+            forwardedCompiler.compile(source, "plugin-forwarded.repl.kts")
+            assertTrue(
+                forwardedCompiler.lastOutputDir.classFileNames().any { it.endsWith(serializerClassSuffix) },
+                "the serialization plugin must generate the serializer class",
+            )
+            forwardedCompiler.compile("User.serializer().descriptor.serialName", "plugin-usage.repl.kts")
+        }
+    }
+
+    @Test
+    fun testStatelessReplReportsAndLoadsSeveralCompilerPluginsRequestedBySingleSnippet() {
+        if (!isK2) return
+
+        withTempDir { workRoot ->
+            val snippetConfiguration = ScriptCompilationConfiguration {
+                compilerPlugins(
+                    ScriptCompilerPlugin.fromClasspath(serializationPluginClasspath()),
+                    ScriptCompilerPlugin.fromClasspath(allOpenPluginClasspath(), listOf(ALL_OPEN_SERIALIZABLE_OPTION)),
+                )
+            }
+            val source = """
+                import kotlinx.serialization.Serializable
+
+                @Serializable
+                class User(val name: String)
+            """.trimIndent()
+            val errors = StatelessReplCompiler(
+                workRoot = workRoot,
+                snippetConfiguration = snippetConfiguration,
+                additionalClasspath = serializationRuntimeClasspath(),
+            ).compileCollectingErrors(source, "plugins-request.repl.kts")
+            val missingPluginsErrors = errors.filter { it.startsWith("Compilation requires compiler plugin ") }
+            assertEquals(2, missingPluginsErrors.size, "Expected a diagnostic per missing plugin, got: $errors")
+
+            val requests = missingPluginsErrors.flatMap { assertNotNull(StatelessReplPluginRequestsCodec.extractMissingPluginRequests(it)) }
+            assertEquals(
+                listOf(serializationPluginRequestKey(), allOpenPluginRequestKey()),
+                requests.map { it.key },
+            )
+            assertEquals(listOf(emptyList(), listOf(ALL_OPEN_SERIALIZABLE_OPTION)), requests.map { it.options })
+            assertEquals(2, requests.map { it.pluginId }.toSet().size, "Expected distinct plugin ids, got: $requests")
+
+            val plugins = StatelessReplCompilerPlugins.EMPTY.merge(requests).valueOrThrow()
+            val forwardedCompiler = StatelessReplCompiler(
+                workRoot = workRoot,
+                snippetConfiguration = snippetConfiguration,
+                loadedPlugins = requests.map { StatelessReplLoadedPlugin(it.key, it.pluginId, it.options) },
+                compilerPluginArguments = plugins.cliArguments(),
+                additionalClasspath = serializationRuntimeClasspath(),
+            )
+            forwardedCompiler.compile(source, "plugins-forwarded.repl.kts")
+            assertTrue(
+                forwardedCompiler.lastOutputDir.classFileNames().any { it.endsWith("User\$\$serializer.class") },
+                "the serialization plugin must generate the serializer class",
+            )
+            // The all-open plugin makes the serializable class open, so it can be subclassed in a later snippet.
+            forwardedCompiler.compile("class Admin(name: String) : User(name)", "plugins-usage.repl.kts")
+        }
+    }
+
+    @Test
+    fun testStatelessReplRejectsConflictingRequestsOfSamePluginInSingleSnippet() {
+        if (!isK2) return
+
+        withTempDir { workRoot ->
+            val compiler = StatelessReplCompiler(
+                workRoot = workRoot,
+                snippetConfiguration = ScriptCompilationConfiguration {
+                    compilerPlugins(
+                        ScriptCompilerPlugin.fromClasspath(allOpenPluginClasspath(), listOf("annotation=test.First")),
+                        ScriptCompilerPlugin.fromClasspath(allOpenPluginClasspath(), listOf("annotation=test.Second")),
+                    )
+                },
+            )
+            val errors = compiler.compileCollectingErrors("1", "plugins-conflict.repl.kts")
+            assertTrue(
+                errors.any { it.contains("conflicting options for compiler plugin", ignoreCase = true) },
+                "Expected a conflict diagnostic, got: $errors",
+            )
+            val requests = errors.mapNotNull(StatelessReplPluginRequestsCodec::extractMissingPluginRequests).flatten()
+            assertEquals(listOf(listOf("annotation=test.First")), requests.map { it.options })
+        }
+    }
+
+    @Test
+    fun testStatelessReplRejectsChangedOptionsForLoadedCompilerPlugin() {
+        if (!isK2) return
+
+        withTempDir { workRoot ->
+            val compiler = StatelessReplCompiler(
+                workRoot = workRoot,
+                snippetConfiguration = serializationPluginConfiguration(listOf("different=true")),
+                loadedPlugins = listOf(
+                    StatelessReplLoadedPlugin(
+                        serializationPluginRequestKey(),
+                        "org.jetbrains.kotlinx.serialization",
+                        emptyList(),
+                    )
+                ),
+                compilerPluginArguments = serializationPluginClasspath().map { "-Xplugin=${it.absolutePath}" },
+            )
+            compiler.compileExpectingFailure(
+                "1",
+                "plugin-conflict.repl.kts",
+                listOf("conflicting options for compiler plugin"),
+            )
+        }
+    }
+
+    @Test
     fun testStatelessReplExecutesMultiSnippetSequence() {
         if (!isK2) return
 
@@ -541,6 +702,9 @@
      * classpath exactly as the hosts do; `null` leaves the transported configuration as the only source.
      */
     private val definitionClass: KClass<*>? = null,
+    private val loadedPlugins: List<StatelessReplLoadedPlugin> = emptyList(),
+    private val compilerPluginArguments: List<String> = emptyList(),
+    private val additionalClasspath: List<File> = emptyList(),
 ) {
     private val snippetConfigurationFile: File? by lazy {
         snippetConfiguration?.let { File(workRoot, "snippet-configuration.bin").also { f -> ReplSnippetConfigurationCodec.writeTo(it, f) } }
@@ -594,6 +758,18 @@
         }
     }
 
+    /** Compiles expecting a compilation error and returns the reported error messages; the session is left untouched. */
+    fun compileCollectingErrors(source: String, name: String): List<String> {
+        val outputDir = File(workRoot, "out-failing-${counter++}").also { it.mkdirs() }
+        val messageCollector = MessageCollectorImpl()
+        val exitCode = withSourceFile(source, name) { scriptFile ->
+            val arguments = getBaseCompilerArgumentsFromProperty().orEmpty() + buildArguments(scriptFile, outputDir)
+            K2JVMCompiler().exec(messageCollector, Services.EMPTY, parseCommandLineArguments<K2JVMCompilerArguments>(arguments))
+        }
+        assertEquals(ExitCode.COMPILATION_ERROR, exitCode, "Unexpected exit code, messages: ${messageCollector.messages}")
+        return messageCollector.errors.map { it.message }
+    }
+
     private fun <R> withSourceFile(source: String, name: String, body: (File) -> R): R {
         val sourceDir = Files.createTempDirectory("k2-repl-cli-src-").toFile()
         try {
@@ -604,8 +780,13 @@
     }
 
     private fun buildArguments(scriptFile: File, outputDir: File): List<String> {
-        val classpathEntries = listOf(ForTestCompileRuntime.runtimeJarForTests()) + priorOutputDirs
+        val classpathEntries = mutableListOf<File>()
+        classpathEntries.add(ForTestCompileRuntime.runtimeJarForTests())
+        classpathEntries.add(ForTestCompileRuntime.scriptingTestsRuntimeClasspathForTests())
+        classpathEntries.addAll(additionalClasspath)
+        classpathEntries.addAll(priorOutputDirs)
         return buildList {
+            addAll(compilerPluginArguments)
             add(K2JVMCompilerArguments::classpath.cliArgument)
             add(classpathEntries.joinToString(File.pathSeparator) { it.absolutePath })
             add(K2JVMCompilerArguments::allowAnyScriptsInSourceRoots.cliArgument)
@@ -616,6 +797,13 @@
                 add("-P")
                 add("plugin:$KOTLIN_SCRIPTING_PLUGIN_ID:repl-snippet-configuration=${it.absolutePath}")
             }
+            loadedPlugins.forEach { [key, pluginId, options] ->
+                add("-P")
+                add(
+                    "plugin:$KOTLIN_SCRIPTING_PLUGIN_ID:repl-snippet-loaded-plugin=" +
+                            StatelessReplPluginRequestsCodec.encodeLoadedPluginOption(key, pluginId, options)
+                )
+            }
             definitionClass?.let {
                 add("-P")
                 add("plugin:$KOTLIN_SCRIPTING_PLUGIN_ID:script-definitions=${it.java.name}")
@@ -637,6 +825,38 @@
     }
 }
 
+private fun serializationRuntimeClasspath(): List<File> =
+    runBlocking {
+        CompoundDependenciesResolver(MavenDependenciesResolver())
+            .resolve("org.jetbrains.kotlinx:kotlinx-serialization-core:1.8.1")
+            .valueOrThrow()
+    }
+
+private fun serializationPluginConfiguration(options: List<String> = emptyList()): ScriptCompilationConfiguration =
+    ScriptCompilationConfiguration {
+        compilerPlugins(ScriptCompilerPlugin.fromClasspath(serializationPluginClasspath(), options))
+    }
+
+private fun serializationPluginClasspath(): List<File> =
+    System.getProperty("kotlin.script.test.kotlinx.serialization.plugin.classpath")
+        ?.split(File.pathSeparator)
+        ?.map(::File)
+        .orEmpty()
+
+private fun serializationPluginRequestKey(): String =
+    serializationPluginClasspath().joinToString(File.pathSeparator) { it.absoluteFile.normalize().path }
+
+private const val ALL_OPEN_SERIALIZABLE_OPTION = "annotation=kotlinx.serialization.Serializable"
+
+private fun allOpenPluginClasspath(): List<File> =
+    System.getProperty("kotlin.script.test.allopen.plugin.classpath")
+        ?.split(File.pathSeparator)
+        ?.map(::File)
+        .orEmpty()
+
+private fun allOpenPluginRequestKey(): String =
+    allOpenPluginClasspath().joinToString(File.pathSeparator) { it.absoluteFile.normalize().path }
+
 private fun File.classFileNames(): List<String> =
     walkTopDown().filter { it.isFile && it.extension == "class" }.map { it.name }.toList()
 
diff --git a/plugins/scripting/scripting-tests/tests/org/jetbrains/kotlin/scripting/test/repl/StatelessReplCompilerPluginsTest.kt b/plugins/scripting/scripting-tests/tests/org/jetbrains/kotlin/scripting/test/repl/StatelessReplCompilerPluginsTest.kt
new file mode 100644
index 0000000..8d995f1
--- /dev/null
+++ b/plugins/scripting/scripting-tests/tests/org/jetbrains/kotlin/scripting/test/repl/StatelessReplCompilerPluginsTest.kt
@@ -0,0 +1,121 @@
+/*
+ * Copyright 2010-2026 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.scripting.compiler.test
+
+import org.jetbrains.kotlin.scripting.compiler.plugin.StatelessReplCompilerPlugins
+import org.jetbrains.kotlin.scripting.compiler.plugin.StatelessReplLoadedPlugin
+import org.jetbrains.kotlin.scripting.compiler.plugin.StatelessReplPluginRequest
+import org.jetbrains.kotlin.scripting.compiler.plugin.StatelessReplPluginRequestsCodec
+import org.junit.jupiter.api.Test
+import java.io.File
+import kotlin.script.experimental.api.valueOrThrow
+import kotlin.test.assertContains
+import kotlin.test.assertEquals
+import kotlin.test.assertFailsWith
+import kotlin.test.assertNull
+
+class StatelessReplCompilerPluginsTest {
+    @Test
+    fun testMergeDeduplicatesEqualRequests() {
+        val request = request()
+
+        val merged = StatelessReplCompilerPlugins.EMPTY.merge(listOf(request, request)).valueOrThrow()
+
+        assertEquals(1, merged.loadedKeys().size)
+        assertEquals(1, merged.cliArguments().count { it.startsWith("-Xplugin=") })
+        assertEquals(1, merged.loadedKeyOptions().size)
+    }
+
+    @Test
+    fun testMergeDeduplicatesSamePluginAcrossRequestKeys() {
+        val request = request()
+        val aliasRequest = request.copy(key = "serialization")
+
+        val merged = StatelessReplCompilerPlugins.EMPTY.merge(listOf(request, aliasRequest)).valueOrThrow()
+
+        assertEquals(listOf(request.key), merged.loadedKeys())
+        assertEquals(1, merged.cliArguments().count { it.startsWith("-Xplugin=") })
+    }
+
+    @Test
+    fun testMergeRejectsConflictingOptions() {
+        val request = request()
+        val conflict = request.copy(options = listOf("disableIntrinsic=false"))
+
+        val failure = assertFailsWith<RuntimeException> {
+            StatelessReplCompilerPlugins.EMPTY.merge(listOf(request, conflict)).valueOrThrow()
+        }
+
+        assertContains(
+            failure.message.orEmpty(),
+            "Conflicting options for compiler plugin '${request.classpath.joinToString(",") { it.path }}'.",
+        )
+    }
+
+    @Test
+    fun testCliArgumentsUseCompatibleLegacySyntax() {
+        val classpath = listOf(File("compiler-plugins/serialization.jar"), File("compiler-plugins/dependency.jar"))
+        val request = StatelessReplPluginRequest(
+            key = "serialization",
+            pluginId = "org.jetbrains.kotlinx.serialization",
+            classpath = classpath,
+            options = listOf("disableIntrinsic=true"),
+        )
+
+        val arguments = StatelessReplCompilerPlugins.EMPTY.merge(listOf(request)).valueOrThrow().cliArguments()
+
+        assertEquals(
+            listOf(
+                "-Xplugin=${classpath[0].path}",
+                "-Xplugin=${classpath[1].path}",
+                "-P",
+                "plugin:org.jetbrains.kotlinx.serialization:disableIntrinsic=true",
+            ),
+            arguments,
+        )
+    }
+
+    @Test
+    fun testRequestAndLoadedPluginCodecsRoundTrip() {
+        val request = request()
+
+        val otherRequest = request.copy(key = "other", pluginId = "other.plugin", options = emptyList())
+
+        val message = StatelessReplPluginRequestsCodec.missingPluginMessage(request)
+        assertEquals(
+            """
+            Compilation requires compiler plugin '${request.key}' (id 'org.jetbrains.kotlinx.serialization'):
+              -Xplugin=${request.classpath.single().path}
+              -P plugin:org.jetbrains.kotlinx.serialization:disableIntrinsic=true
+            """.trimIndent(),
+            message,
+        )
+
+        // Hosts receive the diagnostics rendered with prefixes, possibly several of them per compilation.
+        assertEquals(listOf(request), StatelessReplPluginRequestsCodec.extractMissingPluginRequests("error: $message"))
+        assertEquals(
+            listOf(request, otherRequest),
+            StatelessReplPluginRequestsCodec.extractMissingPluginRequests(
+                "ERROR: $message\nERROR: " + StatelessReplPluginRequestsCodec.missingPluginMessage(otherRequest)
+            )
+        )
+        assertNull(StatelessReplPluginRequestsCodec.extractMissingPluginRequests("error: Compilation requires compiler plugins: x"))
+
+        val loadedPlugin = StatelessReplLoadedPlugin(request.key, request.pluginId, request.options)
+        val encoded = StatelessReplPluginRequestsCodec.encodeLoadedPluginOption(
+            loadedPlugin.key,
+            loadedPlugin.pluginId,
+            loadedPlugin.options,
+        )
+        assertEquals(loadedPlugin, StatelessReplPluginRequestsCodec.decodeLoadedPluginOption(encoded))
+    }
+
+    private fun request(): StatelessReplPluginRequest {
+        val classpath = listOf(File("compiler-plugins/serialization.jar").absoluteFile.normalize())
+        val key = classpath.joinToString(File.pathSeparator) { it.absoluteFile.normalize().path }
+        return StatelessReplPluginRequest(key, "org.jetbrains.kotlinx.serialization", classpath, listOf("disableIntrinsic=true"))
+    }
+}