fix: reconcile lockstep crate bumps to one version

Cargo crates inheriting `version.workspace = true` share a single
`[workspace.package] version`, but the version flow computed a target
version per package independently. Selecting two such crates with
different bumps produced divergent target versions, and `write_version`
wrote them to the one shared slot in HashMap-iteration order — so the
final workspace version was nondeterministic and the crates' tags did not
match what landed on disk.

Add `Adapter::version_groups` (default: none) so an adapter can declare
packages that must move together; the cargo adapter returns its inherited
crates as one group. The version flow then raises every bumped member of
a group to the group's strongest bump before computing versions, so they
resolve to a single deterministic version. Members that received no bump
are left out of the plan — the adapter still moves them via the shared
version and `publish` ships them from the bumped tree.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: Thanga-Ganapathy

crates/adapters/src/cargo.rs

@@ -358,6 +358,31 @@ impl Adapter for CargoAdapter {
         Bump::Patch
     }
 
+    fn version_groups(&self) -> Result<Vec<Vec<String>>> {
+        let root = CargoManifest::read(&self.root.join("Cargo.toml"))?;
+        // Without a shared `[workspace.package] version` nothing is locked together.
+        if root.workspace_version().is_none() {
+            return Ok(Vec::new());
+        }
+        // Every crate that inherits `version.workspace = true` shares the one workspace version,
+        // so they form a single lockstep group.
+        let mut group = Vec::new();
+        for dir in self.member_dirs()? {
+            let manifest = CargoManifest::read(&dir.join("Cargo.toml"))?;
+            if manifest.version_is_inherited() {
+                if let Some(name) = manifest.package_name() {
+                    group.push(name);
+                }
+            }
+        }
+        group.sort();
+        Ok(if group.is_empty() {
+            Vec::new()
+        } else {
+            vec![group]
+        })
+    }
+
     fn is_published(&self, pkg: &Pkg, version: &str) -> Result<bool> {
         let spec = format!("{}@{}", pkg.name, version);
         let out = self.runner.run("cargo", &["info", &spec], &self.root)?;
@@ -547,6 +572,42 @@ mod tests {
         );
     }
 
+    #[test]
+    fn version_groups_locks_only_inherited_crates_together() {
+        let tmp = tempfile::tempdir().unwrap();
+        let root = tmp.path();
+        write(
+            root.join("Cargo.toml"),
+            "[workspace]\nmembers = [\"crates/*\"]\n\n[workspace.package]\nversion = \"1.2.3\"\n",
+        );
+        // Two crates inherit the workspace version; one pins its own.
+        write(
+            root.join("crates/a/Cargo.toml"),
+            "[package]\nname = \"a\"\nversion.workspace = true\n",
+        );
+        write(
+            root.join("crates/b/Cargo.toml"),
+            "[package]\nname = \"b\"\nversion.workspace = true\n",
+        );
+        write(
+            root.join("crates/c/Cargo.toml"),
+            "[package]\nname = \"c\"\nversion = \"0.4.0\"\n",
+        );
+
+        let groups = CargoAdapter::new(root).version_groups().unwrap();
+        assert_eq!(groups, vec![vec!["a".to_string(), "b".to_string()]]);
+    }
+
+    #[test]
+    fn version_groups_empty_without_shared_workspace_version() {
+        // The default `workspace()` fixture pins concrete versions and has no inheriting crate.
+        let tmp = workspace();
+        assert!(CargoAdapter::new(tmp.path())
+            .version_groups()
+            .unwrap()
+            .is_empty());
+    }
+
     #[test]
     fn dependent_bump_is_always_patch_and_range_is_bare() {
         let adapter = CargoAdapter::new(".");

crates/core/src/adapter.rs

@@ -98,6 +98,16 @@ pub trait Adapter {
     /// given a dependency's bump and the edge kind, what bump does the dependent take?
     fn dependent_bump(&self, dep_bump: Bump, kind: &DepKind) -> Bump;
 
+    /// Sets of packages that are versioned in lockstep and must always move to the **same**
+    /// version together — e.g. cargo crates that inherit `version.workspace = true` and share
+    /// one `[workspace.package] version`. Each inner vec is one such group, named by package.
+    ///
+    /// Default: no groups (every package is versioned independently). The `version` flow uses
+    /// this to reconcile a group's members to a single bump, so they cannot diverge.
+    fn version_groups(&self) -> Result<Vec<Vec<String>>> {
+        Ok(Vec::new())
+    }
+
     /// Registry check: is `version` of `pkg` already published? Used to make publish idempotent.
     fn is_published(&self, pkg: &Pkg, version: &str) -> Result<bool>;
 

crates/core/src/version.rs

@@ -225,7 +225,9 @@ pub fn orchestrate_many(
             .map(|(name, bump)| (name.clone(), bump.clone()))
             .collect();
         let graph = Graph::build(&ctx.packages)?;
-        let bumps = graph.cascade(ctx.adapter, &selected_for_adapter)?;
+        let mut bumps = graph.cascade(ctx.adapter, &selected_for_adapter)?;
+        // Lockstep crates share one version; reconcile their bumps so they can't diverge.
+        reconcile_version_groups(&mut bumps, &ctx.adapter.version_groups()?);
         for (name, bump) in &bumps {
             let pkg = by_name[name.as_str()];
             new_versions.insert(name.clone(), apply_bump(&pkg.version, bump)?);
@@ -388,6 +390,29 @@ pub fn orchestrate_many(
     Ok(())
 }
 
+/// Raise every bumped member of each lockstep group to the strongest (max) bump in its group, so
+/// packages versioned together (cargo `version.workspace = true`) resolve to one deterministic
+/// version instead of diverging by the order their manifests were written. Members that received
+/// no bump are left untouched — the adapter still moves them on disk via the shared version, and
+/// `publish` ships them from the bumped working tree.
+fn reconcile_version_groups(bumps: &mut HashMap<String, Bump>, groups: &[Vec<String>]) {
+    for group in groups {
+        let Some(max) = group
+            .iter()
+            .filter_map(|name| bumps.get(name))
+            .max()
+            .cloned()
+        else {
+            continue; // no member of this group was bumped
+        };
+        for name in group {
+            if let Some(slot) = bumps.get_mut(name) {
+                *slot = max.clone();
+            }
+        }
+    }
+}
+
 /// Apply a bump to an `x.y.z` version (pre-release/build metadata is dropped unless entering/iterating prerelease).
 fn apply_bump(version: &str, bump: &Bump) -> Result<String> {
     let mut parts = version.split('-');
@@ -480,6 +505,7 @@ mod tests {
 
     struct FakeVersionAdapter {
         packages: Vec<Pkg>,
+        groups: Vec<Vec<String>>,
         writes: RefCell<Vec<(String, String)>>,
         lockfile_updates: RefCell<usize>,
     }
@@ -492,10 +518,16 @@ mod tests {
         fn with_packages(packages: Vec<Pkg>) -> Self {
             Self {
                 packages,
+                groups: Vec::new(),
                 writes: RefCell::new(Vec::new()),
                 lockfile_updates: RefCell::new(0),
             }
         }
+
+        fn with_lockstep_group(mut self, names: &[&str]) -> Self {
+            self.groups = vec![names.iter().map(|n| n.to_string()).collect()];
+            self
+        }
     }
 
     impl Adapter for FakeVersionAdapter {
@@ -531,6 +563,10 @@ mod tests {
             Bump::Patch
         }
 
+        fn version_groups(&self) -> Result<Vec<Vec<String>>> {
+            Ok(self.groups.clone())
+        }
+
         fn is_published(&self, _: &Pkg, _: &str) -> Result<bool> {
             Ok(false)
         }
@@ -628,6 +664,25 @@ mod tests {
         }
     }
 
+    /// Selects every pending package and returns a per-package bump from a scripted map.
+    struct ScriptedBumpPrompt {
+        bumps: HashMap<String, Bump>,
+    }
+
+    impl Prompt for ScriptedBumpPrompt {
+        fn select_packages(&self, pending: &[&Pkg]) -> Result<Vec<String>> {
+            Ok(pending.iter().map(|pkg| pkg.name.clone()).collect())
+        }
+
+        fn choose_bump(&self, name: &str, _: &str) -> Result<Bump> {
+            Ok(self.bumps[name].clone())
+        }
+
+        fn confirm(&self, _: &str) -> Result<bool> {
+            Ok(true)
+        }
+    }
+
     struct FakeForge {
         prs: RefCell<Vec<String>>,
     }
@@ -838,4 +893,78 @@ mod tests {
             "the curated notes must survive:\n{after}"
         );
     }
+
+    #[test]
+    fn reconcile_version_groups_raises_bumped_members_to_max() {
+        let mut bumps = HashMap::from([
+            ("a".to_string(), Bump::Minor),
+            ("b".to_string(), Bump::Major),
+            ("loner".to_string(), Bump::Patch),
+        ]);
+        let groups = vec![
+            vec!["a".to_string(), "b".to_string(), "c".to_string()],
+            vec!["loner".to_string()],
+        ];
+        reconcile_version_groups(&mut bumps, &groups);
+
+        // a and b were both bumped → both raised to the group max (major).
+        assert_eq!(bumps["a"], Bump::Major);
+        assert_eq!(bumps["b"], Bump::Major);
+        // c got no bump and stays absent (the adapter still moves it via the shared version).
+        assert!(!bumps.contains_key("c"));
+        // A singleton group is unaffected.
+        assert_eq!(bumps["loner"], Bump::Patch);
+    }
+
+    #[test]
+    fn lockstep_group_selected_with_different_bumps_resolves_to_one_version() {
+        let tmp = tempfile::tempdir().unwrap();
+        let root = tmp.path();
+        // Two lockstep crates at the same shared version, picked with *different* bumps.
+        let adapter = FakeVersionAdapter::with_packages(vec![
+            test_pkg(root, "crate-a"),
+            test_pkg(root, "crate-b"),
+        ])
+        .with_lockstep_group(&["crate-a", "crate-b"]);
+        let git = FakeGit::new();
+        let forge = FakeForge {
+            prs: RefCell::new(Vec::new()),
+        };
+        let prompt = ScriptedBumpPrompt {
+            bumps: HashMap::from([
+                ("crate-a".to_string(), Bump::Major),
+                ("crate-b".to_string(), Bump::Minor),
+            ]),
+        };
+        let config = crate::config::ReleaseConfig {
+            changelog_strategy: crate::config::ChangelogStrategy::Curated,
+            ..Default::default()
+        };
+
+        orchestrate_many(
+            &[&adapter],
+            &FakeRepo,
+            &git,
+            &forge,
+            &prompt,
+            root,
+            "2026-06-28",
+            &VersionOptions::default(),
+            &config,
+            &crate::hooks::fakes::FakeHookRunner::new(),
+        )
+        .unwrap();
+
+        // Both crates are written to the same version — the strongest (major) bump wins — instead
+        // of diverging (2.0.0 vs 1.1.0) by write order.
+        let mut writes = adapter.writes.borrow().clone();
+        writes.sort();
+        assert_eq!(
+            writes,
+            [
+                ("crate-a".to_string(), "2.0.0".to_string()),
+                ("crate-b".to_string(), "2.0.0".to_string()),
+            ]
+        );
+    }
 }