@@ -11,9 +11,23 @@ plugins {
     alias(libs.plugins.ksp).apply(false)
 }
 
+// One published version for every artifact (#70): "$pythonVersion-$libraryVersionSuffix", the same
+// value python-multiplatform and the included Gradle-plugin build derive from gradle.properties.
+val publishedVersion = "${property("pythonVersion")}-${property("libraryVersionSuffix")}"
+
 allprojects {
     group = "io.github.thisisthepy"
-    version = "3.13.0"  // Official Python release version
+    version = publishedVersion
+}
+
+// Fails the build when any project in this build publishes under another version; the plugin build
+// checks its own the same way (python-multiplatform-gradle-plugin/build.gradle.kts).
+gradle.projectsEvaluated {
+    val wrong = rootProject.allprojects.filter { it.version.toString() != publishedVersion }
+    check(wrong.isEmpty()) {
+        "published versions disagree (#70): expected $publishedVersion, got " +
+            wrong.joinToString { "${it.path}=${it.version}" }
+    }
 }
 
 // ROADMAP §15a/§15e item 3: `python-multiplatform-gradle-plugin` is a separate included build
 
@@ -304,13 +304,10 @@ Old §15a, §15b, §15d, §15f, §15g, §15h are closed; §15e item 4 is closed
   configured (`signing { }` is commented out in `python-multiplatform/build.gradle.kts`), and
   `repo1.maven.org/maven2/io/github/thisisthepy/python-multiplatform/` returns 404 (2026-10-03).
   Every consumer verification so far used `mavenLocal()`. 10.1 depends on this or on a release asset.
-- **15.2 The KSP processor and plugin versions are hand-copied literals, open.** Root
-  `build.gradle.kts` `allprojects { version = "3.13.0" }` (inherited by `python-multiplatform-ksp`) and
-  `python-multiplatform-gradle-plugin/build.gradle.kts` `version = "3.13.0"` agree only by hand, while
-  the library publishes `3.14.7-alpha01` from `gradle.properties`. The plugin bakes
-  `DEFAULT_PROCESSOR_COORDINATES` from its own version, so the two literals drifting would reproduce
-  the "processor coordinate that exists nowhere" defect with no configuration-time error. A check, or
-  one source for both, is what is left.
+- **15.2 The library, KSP processor and plugin publish under one version, done (#70).** Each build
+  derives it from `gradle.properties` (`$pythonVersion-$libraryVersionSuffix`, a `-P` override included);
+  the root build fails when a project's version differs, and `PublishedVersionTest` pins the processor
+  and wasm-runtime coordinates the plugin bakes to that version.
 - **15.3 `stagePythonHome` has run only on `macos-aarch64`, partial.** Linux-x86_64, macOS-x86_64 and
   Windows-x86_64 are pinned as string assertions in `PythonHomeStagingTest`; Windows' `Lib/`+`DLLs/`
   layout and `linux-aarch64` (no `libpython` in `desktopJar`, relies on `manager.loadFromSidecar`) have
 
@@ -31,6 +31,10 @@ pythonVersion=3.15.0
 pythonFreeThreaded=false
 pythonBuildStandaloneRelease=20261013
 pythonAppleSupportBuild=b11
+# Every published artifact (library, KSP processor, Gradle plugin) is versioned
+# "$pythonVersion-$libraryVersionSuffix"; each build derives it from these two values and fails if
+# its own version disagrees (#70).
+libraryVersionSuffix=alpha01
 
 # GraalVM native-image (sample's nativeCompile task). Liberica NIK is not in a location Gradle's
 # toolchain auto-detection scans, so it is registered explicitly here. Adding a path only makes a
 
@@ -8,7 +8,17 @@ plugins {
 }
 
 group = "io.github.thisisthepy"
-version = "3.13.0" // kept in step with the root build's version, which the processor is published under
+// Same published version as the library and the KSP processor (#70): "$pythonVersion-$suffix" from
+// the root's gradle.properties, a -P override winning as it does in the root build (Gradle hands
+// start-parameter properties to included builds too).
+val rootGradleProperties = Properties().apply {
+    val file = rootDir.resolve("../gradle.properties")
+    if (file.isFile) file.inputStream().use { load(it) }
+}
+fun rootProperty(name: String, fallback: String): String =
+    findProperty(name)?.toString() ?: rootGradleProperties.getProperty(name) ?: fallback
+val publishedVersion = "${rootProperty("pythonVersion", "3.15.0")}-${rootProperty("libraryVersionSuffix", "alpha01")}"
+version = publishedVersion
 
 /**
  * `KlibScanner`'s reader, named once because three places have to agree on it: this module's own
@@ -239,20 +249,13 @@ val generateCoordinates = tasks.register("generateCoordinates") {
     // second copy of these values that drifted would pair a stdlib with an interpreter from a
     // different build. The fallbacks match `python-multiplatform/build.gradle.kts`'s own, for the
     // case where this build is checked out without the root's properties beside it.
-    val rootProperties = Properties().apply {
-        val file = rootDir.resolve("../gradle.properties")
-        if (file.isFile) file.inputStream().use { load(it) }
-    }
-    val pythonVersionValue = rootProperties.getProperty("pythonVersion") ?: "3.15.0"
-    val pbsReleaseValue = rootProperties.getProperty("pythonBuildStandaloneRelease") ?: "20261013"
-    val freeThreadedValue = rootProperties.getProperty("pythonFreeThreaded")?.toBoolean() ?: false
+    val pythonVersionValue = rootProperty("pythonVersion", "3.15.0")
+    val pbsReleaseValue = rootProperty("pythonBuildStandaloneRelease", "20261013")
+    val freeThreadedValue = rootProperty("pythonFreeThreaded", "false").toBoolean()
 
-    // `python-multiplatform` itself is versioned "$pythonVersion-alpha01" -- see that build's own
-    // `val libraryVersion` -- which is *not* this plugin build's `project.version` (kept in step by
-    // hand, see the top of this file). The wasm-runtime zip is published under the library's
-    // version, alongside the library artifact it has to pair with, so the coordinate has to be
-    // built the same way rather than reusing this plugin's own version.
-    val libraryVersionValue = "$pythonVersionValue-alpha01"
+    // The library and this plugin publish under one version since #70, so the wasm-runtime zip
+    // (published beside the library artifact) is at this build's own version.
+    val libraryVersionValue = publishedVersion
     val wasmRuntimeCoordinatesValue = "${project.group}:python-multiplatform-wasm-runtime:$libraryVersionValue"
 
     val klibWorkerValue = klibWorkerCoordinates
 
@@ -0,0 +1,37 @@
+package python.multiplatform.gradle
+
+import java.io.File
+import java.util.Properties
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+/**
+ * Issue #70: the library, the KSP processor and this plugin publish under one version,
+ * "$pythonVersion-$libraryVersionSuffix" from the root `gradle.properties`. The plugin hands a
+ * consumer the processor's and the wasm runtime's coordinates at its own version, so both must carry
+ * exactly the library's version: a plugin left at an older number (it was 3.13.0 beside a 3.14.7
+ * library) would resolve a processor nobody published with that library.
+ */
+class PublishedVersionTest {
+
+    private val expected: String = Properties().run {
+        File("../gradle.properties").inputStream().use { load(it) }
+        "${getProperty("pythonVersion")}-${getProperty("libraryVersionSuffix")}"
+    }
+
+    @Test
+    fun theProcessorCoordinateCarriesTheLibraryVersion() {
+        assertEquals(
+            "io.github.thisisthepy:python-multiplatform-ksp:$expected",
+            DEFAULT_PROCESSOR_COORDINATES,
+        )
+    }
+
+    @Test
+    fun theWasmRuntimeCoordinateCarriesTheLibraryVersion() {
+        assertEquals(
+            "io.github.thisisthepy:python-multiplatform-wasm-runtime:$expected",
+            DEFAULT_WASM_RUNTIME_COORDINATES,
+        )
+    }
+}
@@ -62,13 +62,13 @@ plugins {
 }
 
 
-val configuredPythonVersion = project.findProperty("pythonVersion")?.toString() ?: project.rootProject.version.toString()
+val configuredPythonVersion = project.property("pythonVersion").toString()
 val pythonFreeThreaded = project.findProperty("pythonFreeThreaded")?.toString()?.toBoolean() ?: false
 val pbsRelease = project.findProperty("pythonBuildStandaloneRelease")?.toString() ?: "20261013"
 val pythonAppleSupportBuild = project.findProperty("pythonAppleSupportBuild")?.toString() ?: "b11"
 
 val pythonVersion = configuredPythonVersion
-val libraryVersion = "$pythonVersion-alpha01"
+val libraryVersion = "$pythonVersion-${project.property("libraryVersionSuffix")}"   // the root's publishedVersion (#70)
 version = libraryVersion
 
 buildkonfig {