@@ -71,10 +71,8 @@ selectors or shared `latest` pages.
 The workflow revision used for a release is its **control revision**; the
 tagged commit is its **source revision**. Record both and the artifact CI run
 ID. Release routing uses the package layout and toolkit settings in
-`ci/versions.yml` at the release tag. When retrying an interrupted CUDA 13
-release, retained tags can use their original configuration, source layout,
-build matrix, and artifact names while those artifacts remain available.
-New CUDA 12 releases require the local `cuda_bindings_12` directory and
+the release tag's `ci/versions.yml`, which must contain the
+`schema_version: 2` package-root registry. Both bindings lines require
 toolkit-qualified artifacts. The workflow control revision never supplies
 missing tagged toolkit settings or replaces tagged release notes.
 
@@ -88,6 +86,15 @@ Local synthetic tags used in publication-incapable rehearsals must remain local;
 they do not authorize publishing a package, creating a remote tag, or moving
 an existing tag.
 
+### Older release layouts
+
+For tags without the package-root registry, run the release workflow from an
+appropriate historical tag or maintenance branch, using that ref's own inputs.
+Select a branch in Actions' **Run workflow** menu, or select a branch or tag
+with the GitHub CLI's `--ref` option. Verify its release flow and artifact
+availability before use. Older-tag docs rebuilds also need a caller on a
+compatible ref: `build-docs.yml` is reusable and cannot be dispatched directly.
+
 ### Two tags at one commit
 
 One tested source commit can carry tags for both bindings lines, for example
 
@@ -21,8 +21,10 @@ docs build prevents asset uploads, package publication, and finalization.
 
 The workflow revision supplies the release tools; release notes and the
 package registry (`ci/versions.yml`) come from `git-tag`. Current tooling
-uses the toolkit configuration in the tagged source, including retained CUDA 13
-sources that predate the package-root registry. The release-notes job exports
+requires that source to use the `schema_version: 2` package-root registry.
+For older layouts, select a compatible historical workflow ref as described
+in the [bindings release guide](RELEASE-bindings.md#older-release-layouts).
+The release-notes job exports
 the checked version and rejects an empty version before documentation, asset
 uploads, or package publication can start. Pathfinder package publication also
 requires successful draft metadata preparation. Existing tags stay immutable.
 
@@ -263,6 +263,10 @@ setuptools-scm's default tag parser. Each root's `git_describe_command`
 selects its CUDA ABI major for source builds (`v12.*` or `v13.*`),
 independently of the toolkit minor used to build it.
 
+Release workflows on `main` require `schema_version: 2` in the tagged source
+too. For older layouts, use an appropriate historical workflow ref and its
+own inputs; see [older release layouts](../.github/RELEASE-bindings.md#older-release-layouts).
+
 The repository-private `cuda-python-ci-tools` package provides the shared
 configuration readers and their dependencies. Workflows use these helpers
 from their control revision when inspecting another source revision. Install
@@ -373,8 +377,10 @@ source revision; the helper comes from the workflow control revision.
 directories on `main`. The registry identifies CUDA 12 as the maintenance
 line. Routine CUDA 12 fixes, tests, and documentation belong in
 `cuda_bindings_12/`. The old `12.9.x` branch stays frozen except for emergency
-fixes using compatible historical tooling; reconcile any such fix into the
-CUDA 12 directory on `main` and assess the CUDA 13 directory too.
+fixes using compatible historical tooling. Release old-layout tags from a
+validated workflow on the appropriate maintenance branch or historical tag,
+rather than from `main`. Reconcile any emergency fix into the CUDA 12 directory
+on `main` and assess the CUDA 13 directory too.
 
 For independent releases from a shared source commit, see
 [two tags at one commit](../.github/RELEASE-bindings.md#two-tags-at-one-commit).
 
@@ -120,7 +120,7 @@ def wheel_python_versions(toolkit_version: str, platform: str, versions: Sequenc
     if platform == "win-arm64":
         if Version(toolkit_version).release[:2] < (13, 4):
             return []
-        # Retained release tags can include Python 3.10, which has no WoA wheels.
+        # Python 3.10 has no Windows ARM64 wheels.
         return [version for version in versions if version != "3.10"]
     return list(versions)
 
@@ -207,7 +207,7 @@ def resolve_release_bindings_package(
     release_tag: str,
     release_source_root: Path,
 ) -> dict[str, object]:
-    """Resolve a release from its tagged source, including retained CUDA 13 tags."""
+    """Resolve a release from the package registry in its tagged source."""
     if not release_source_root.is_dir():
         raise ValueError(f"release source root is not a directory: {release_source_root}")
 
@@ -220,47 +220,23 @@ def resolve_release_bindings_package(
         raise ValueError(f"unsupported release tag: {release_tag!r}")
 
     try:
-        raw = yaml.safe_load(config_path.read_text(encoding="utf-8"))
-        legacy_config = "schema_version" not in raw
-        if legacy_config:
-            current_toolkit = raw["cuda"]["build"]["version"]
-            if _TOOLKIT_VERSION_PATTERN.fullmatch(current_toolkit) is None or not current_toolkit.startswith("13."):
-                raise ValueError("legacy release compatibility requires a CUDA 13 build toolkit")
-            current_root = (
-                "cuda_bindings_13" if (release_source_root / "cuda_bindings_13").is_dir() else "cuda_bindings"
-            )
-            package = BindingsPackage(current_root, tuple(map(int, current_toolkit.split("."))), "current")
-            if bindings_version is not None and bindings_version.release[0] == 12:
-                maintenance_toolkit = raw["cuda"]["prev_build"]["version"]
-                if _TOOLKIT_VERSION_PATTERN.fullmatch(maintenance_toolkit) is None:
-                    raise ValueError("legacy prev_build toolkit must have major.minor.patch format")
-                package = BindingsPackage(
-                    "cuda_bindings_12", tuple(map(int, maintenance_toolkit.split("."))), "maintenance"
-                )
-        else:
-            config = parse_config(raw)
-            package = (
-                config.package_for_release_status("current") if is_dependent_release else config.match_tag(release_tag)
-            )
+        config = load_config(config_path)
+        package = (
+            config.package_for_release_status("current") if is_dependent_release else config.match_tag(release_tag)
+        )
     except (OSError, yaml.YAMLError, KeyError, TypeError, ValueError) as error:
         raise ValueError(f"could not resolve release source config {config_path}: {error}") from error
     if package is None:
         raise ValueError(
             f"no CUDA bindings package root in tagged config {config_path} matches release tag: {release_tag!r}"
         )
-    if bindings_version is not None and not package.matches_tag(release_tag):
-        raise ValueError(f"release tag {release_tag!r} does not match tagged toolkit {package.toolkit_version}")
-    if legacy_config and not (release_source_root / package.package_root).is_dir():
-        raise ValueError(f"tagged source has no bindings root {package.package_root!r}")
 
     record: dict[str, object] = {
         "package_root": package.package_root,
         "toolkit_version": package.toolkit_version,
     }
     if bindings_version is not None:
         record["release_version"] = str(bindings_version)
-    if legacy_config and package.release_status == "current":
-        record["allow_legacy_python_artifact"] = True
     return record
 
 
 
@@ -128,11 +128,6 @@ if [[ "$IS_BINDINGS_RELEASE" == true && "$COMPONENT" == "cuda-python" ]]; then
     ARTIFACT_NAME="cuda-python-wheel-cuda${TOOLKIT_VERSION}"
     if grep -Fxq "$ARTIFACT_NAME" <<< "$ARTIFACT_NAMES"; then
         MATCHING_ARTIFACTS+=("$ARTIFACT_NAME")
-    elif [[ "$TOOLKIT_VERSION" == 13.* ]] \
-        && jq -e '.allow_legacy_python_artifact == true' \
-            <<< "$RESOLVED_BINDINGS_PACKAGE_JSON" >/dev/null \
-        && grep -Fxq "cuda-python-wheel" <<< "$ARTIFACT_NAMES"; then
-        MATCHING_ARTIFACTS+=("cuda-python-wheel")
     fi
 else
     if [[ "$IS_BINDINGS_RELEASE" == true ]]; then
 
@@ -9,55 +9,42 @@
 from ci.tools.bindings_config import main, parse_config, resolve_release_bindings_package, write_github_env
 
 
-def _source(root, *, old=False, schema2=False):
-    current_root = "cuda_bindings" if old else "cuda_bindings_13"
+def _source(root):
     packages = {
         "cuda_bindings_12": {"toolkit_version": "12.9.1", "release_status": "maintenance"},
-        current_root: {"toolkit_version": "13.4.2", "release_status": "current"},
+        "cuda_bindings_13": {"toolkit_version": "13.4.2", "release_status": "current"},
+    }
+    raw = {
+        "schema_version": 2,
+        "python": {"supported": ["3.11", "3.14t"]},
+        "cuda": {"bindings": {"package_roots": packages}},
     }
-    raw = {"cuda": {"build": {"version": "13.4.2"}, "prev_build": {"version": "12.9.1"}}}
-    if not old:
-        raw["python"] = {"supported": ["3.11", "3.14t"]}
-    if schema2:
-        raw["schema_version"] = 2
-        raw["cuda"] = {"bindings": {"package_roots": packages}}
     config = root / "ci" / "versions.yml"
     config.parent.mkdir(parents=True)
     config.write_text(yaml.safe_dump(raw))
-    (root / current_root).mkdir()
-    if not old:
-        (root / "cuda_bindings_12").mkdir()
+    for package_root in packages:
+        (root / package_root).mkdir()
     return root, raw
 
 
 @pytest.mark.parametrize(
-    ("old", "schema2", "tag", "expected_root", "legacy_artifact"),
+    ("tag", "expected_root"),
     [
-        (True, False, "v13.4.4", "cuda_bindings", True),
-        (False, False, "v12.9.11", "cuda_bindings_12", False),
-        (False, True, "v12.9.11", "cuda_bindings_12", False),
-        (False, True, "v13.4.9", "cuda_bindings_13", False),
+        ("v12.9.11", "cuda_bindings_12"),
+        ("v13.4.9", "cuda_bindings_13"),
     ],
 )
 @pytest.mark.agent_authored(model="gpt-6")
-def test_tagged_source_compatibility(tmp_path, old, schema2, tag, expected_root, legacy_artifact):
-    source, _ = _source(tmp_path, old=old, schema2=schema2)
+def test_tagged_source_routes_both_bindings_majors(tmp_path, tag, expected_root):
+    source, _ = _source(tmp_path)
     record = resolve_release_bindings_package(tag, source)
     assert record["package_root"] == expected_root
     assert record["release_version"] == tag.removeprefix("v")
-    assert record.get("allow_legacy_python_artifact", False) is legacy_artifact
-
-
-@pytest.mark.agent_authored(model="gpt-6")
-def test_old_cuda13_source_cannot_resolve_cuda12(tmp_path):
-    source, _ = _source(tmp_path, old=True)
-    with pytest.raises(ValueError, match="no bindings root"):
-        resolve_release_bindings_package("v12.9.11", source)
 
 
 @pytest.mark.agent_authored(model="gpt-6")
 def test_release_cli_uses_tagged_source_without_control_fallback(tmp_path, capsys):
-    source, _ = _source(tmp_path / "tagged", old=True)
+    source, _ = _source(tmp_path / "tagged")
     assert (
         main(
             [
@@ -72,10 +59,9 @@ def test_release_cli_uses_tagged_source_without_control_fallback(tmp_path, capsy
         == 0
     )
     assert json.loads(capsys.readouterr().out) == {
-        "package_root": "cuda_bindings",
+        "package_root": "cuda_bindings_13",
         "toolkit_version": "13.4.2",
         "release_version": "13.4.4",
-        "allow_legacy_python_artifact": True,
     }
     empty = tmp_path / "absent-source"
     empty.mkdir()
@@ -94,7 +80,7 @@ def test_release_cli_uses_tagged_source_without_control_fallback(tmp_path, capsy
 
 @pytest.mark.agent_authored(model="gpt-6")
 def test_dependent_release_uses_current_tagged_bindings(tmp_path):
-    source, _ = _source(tmp_path, schema2=True)
+    source, _ = _source(tmp_path)
     assert resolve_release_bindings_package("cuda-core-v1.2.0", source) == {
         "package_root": "cuda_bindings_13",
         "toolkit_version": "13.4.2",
@@ -104,7 +90,7 @@ def test_dependent_release_uses_current_tagged_bindings(tmp_path):
 @pytest.mark.parametrize("conflict", ["roles", "majors"])
 @pytest.mark.agent_authored(model="gpt-6")
 def test_schema2_rejects_ambiguous_release_routing(tmp_path, conflict):
-    _, raw = _source(tmp_path, schema2=True)
+    _, raw = _source(tmp_path)
     maintenance = raw["cuda"]["bindings"]["package_roots"]["cuda_bindings_12"]
     maintenance["release_status" if conflict == "roles" else "toolkit_version"] = (
         "current" if conflict == "roles" else "13.4.1"
 
@@ -129,22 +129,3 @@ def test_nonrelease_components_stage_wheels_without_test_artifacts(tmp_path, com
     )
     assert result.returncode == 0, result.stderr
     assert {path.name for path in (tmp_path / "dist").iterdir()} == {f"{artifact}.whl" for artifact in expected}
-
-
-@pytest.mark.parametrize(
-    ("toolkit", "artifacts", "expected"),
-    [
-        ("13.4.2", ["cuda-python-wheel"], "cuda-python-wheel"),
-        ("13.4.2", ["cuda-python-wheel", "cuda-python-wheel-cuda13.4.2"], "cuda-python-wheel-cuda13.4.2"),
-        ("12.9.1", ["cuda-python-wheel"], None),
-    ],
-)
-@pytest.mark.agent_authored(model="GPT-6")
-def test_legacy_metapackage_fallback_is_limited_to_cuda_13(tmp_path, toolkit, artifacts, expected):
-    package = {"toolkit_version": toolkit, "allow_legacy_python_artifact": True}
-    result = run_download(tmp_path, artifacts, "cuda-python", package=package, tag=f"v{toolkit}")
-
-    assert (result.returncode == 0) == (expected is not None), result.stderr
-    assert {path.name for path in (tmp_path / "dist").glob("*.whl")} == (
-        set() if expected is None else {f"{expected}.whl"}
-    )
@@ -203,19 +203,3 @@ def test_cuda_core_uses_the_complete_binary_wheel_matrix(tmp_path):
     )
 
     assert result.returncode == 0, result.stderr
-
-
-@pytest.mark.agent_authored(model="GPT-6")
-def test_retained_tag_uses_its_build_workflow_python_matrix(tmp_path):
-    write_release_matrix(tmp_path, platforms=("linux-64", "win-arm64"))
-    (tmp_path / "ci/versions.yml").write_text("cuda:\n  build:\n    version: '13.4.2'\n", encoding="utf-8")
-    (tmp_path / ".github/workflows/build-wheel.yml").write_text(
-        yaml.safe_dump({"jobs": {"build": {"strategy": {"matrix": {"python-version": ["3.10", "3.12"]}}}}}),
-        encoding="utf-8",
-    )
-
-    assert expected_binary_targets(tmp_path, {"toolkit_version": "13.4.2"}) == {
-        WheelTarget("cp310", "cp310", "manylinux-x86_64"),
-        WheelTarget("cp312", "cp312", "manylinux-x86_64"),
-        WheelTarget("cp312", "cp312", "win_arm64"),
-    }
@@ -89,11 +89,7 @@ def version_from_tag(
 def _release_python_versions(release_source_root: Path) -> list[str]:
     path = release_source_root / _VERSIONS_CONFIG
     config = yaml.safe_load(path.read_text(encoding="utf-8"))
-    if "python" in config or "schema_version" in config:
-        return config["python"]["supported"]
-    # Retained CUDA 13 tags predate the shared Python-version list.
-    workflow = release_source_root / ".github/workflows/build-wheel.yml"
-    return yaml.safe_load(workflow.read_text(encoding="utf-8"))["jobs"]["build"]["strategy"]["matrix"]["python-version"]
+    return config["python"]["supported"]
 
 
 def _release_platforms(release_source_root: Path) -> set[str]: