fix(valgrind): compare codspeed iteration of installed valgrind

Previously only the upstream semver was compared, so a cached
3.26.0.codspeed2 build still satisfied the 3.26.0-0codspeed3 pin and
stale valgrind builds were restored from the CI cache instead of being
reinstalled. Compare the (semver, iteration) pair against the pinned
values, treating legacy `.codspeed` builds without an iteration as
iteration 0. The pinned iteration is a single constant that also forms
the .deb revision, so future bumps stay in one place.

Fixes COD-2782
Co-Authored-By: Claude <noreply@anthropic.com>

Author: not-matthias

src/binary_pins.rs

@@ -9,13 +9,18 @@ use std::sync::LazyLock;
 /// download (combined with `VALGRIND_DEB_REV`) and for detecting an already
 /// installed copy.
 pub const VALGRIND_CODSPEED_VERSION: Version = Version::new(3, 26, 0);
+/// CodSpeed repackaging iteration of `VALGRIND_CODSPEED_VERSION`. Bumps when
+/// the .deb is repackaged without a new upstream valgrind release. Appears in
+/// the .deb package version (`3.26.0-0codspeed3`) and in `valgrind --version`
+/// output (`valgrind-3.26.0.codspeed3`).
+pub const VALGRIND_CODSPEED_ITERATION: u32 = 3;
 /// Suffix appended to `VALGRIND_CODSPEED_VERSION` to form the .deb package version.
-/// Bumps when the .deb is repackaged without a new upstream valgrind release.
-const VALGRIND_DEB_REV: &str = "0codspeed3";
-/// String form of `VALGRIND_CODSPEED_VERSION` as it appears in `valgrind --version`
+static VALGRIND_DEB_REV: LazyLock<String> =
+    LazyLock::new(|| format!("0codspeed{VALGRIND_CODSPEED_ITERATION}"));
+/// String form of the pinned version as it appears in `valgrind --version`
 /// output, used to identify a CodSpeed build at runtime.
 pub static VALGRIND_CODSPEED_VERSION_STRING: LazyLock<String> =
-    LazyLock::new(|| format!("{VALGRIND_CODSPEED_VERSION}.codspeed"));
+    LazyLock::new(|| format!("{VALGRIND_CODSPEED_VERSION}.codspeed{VALGRIND_CODSPEED_ITERATION}"));
 
 #[derive(Debug, Clone, Copy)]
 struct BinaryPin {
@@ -74,7 +79,7 @@ pub struct ValgrindTarget {
 }
 
 static VALGRIND_DEB_VERSION: LazyLock<String> =
-    LazyLock::new(|| format!("{VALGRIND_CODSPEED_VERSION}-{VALGRIND_DEB_REV}"));
+    LazyLock::new(|| format!("{VALGRIND_CODSPEED_VERSION}-{}", VALGRIND_DEB_REV.as_str()));
 const VALGRIND_DEB_URL_TEMPLATE: &str = "https://github.com/CodSpeedHQ/valgrind-codspeed/releases/download/{version}/valgrind_{version}_ubuntu-{distro_version}_{arch}.deb";
 
 impl ValgrindTarget {

src/executor/valgrind/setup.rs

@@ -1,6 +1,6 @@
 use crate::binary_pins::{
-    Arch, DistroVersion, PinnedBinary, VALGRIND_CODSPEED_VERSION, VALGRIND_CODSPEED_VERSION_STRING,
-    ValgrindTarget,
+    Arch, DistroVersion, PinnedBinary, VALGRIND_CODSPEED_ITERATION, VALGRIND_CODSPEED_VERSION,
+    VALGRIND_CODSPEED_VERSION_STRING, ValgrindTarget,
 };
 use crate::cli::run::helpers::download_pinned_file;
 use crate::executor::helpers::apt;
@@ -126,45 +126,47 @@ pub fn get_valgrind_status() -> ToolStatus {
         .trim()
         .to_string();
 
+    ToolStatus {
+        tool_name,
+        status: classify_valgrind_version(version),
+    }
+}
+
+/// Classify a trimmed `valgrind --version` output against the pinned CodSpeed
+/// valgrind version.
+fn classify_valgrind_version(version: String) -> ToolInstallStatus {
     // Check if it's a codspeed version
     if !version.contains(".codspeed") {
-        return ToolStatus {
-            tool_name,
-            status: ToolInstallStatus::IncorrectVersion {
-                version,
-                message: "not a CodSpeed build".to_string(),
-            },
+        return ToolInstallStatus::IncorrectVersion {
+            version,
+            message: "not a CodSpeed build".to_string(),
         };
     }
 
     // Parse the installed version
     let Some(installed_version) = parse_valgrind_codspeed_version(&version) else {
-        return ToolStatus {
-            tool_name,
-            status: ToolInstallStatus::IncorrectVersion {
-                version,
-                message: "could not parse version".to_string(),
-            },
+        return ToolInstallStatus::IncorrectVersion {
+            version,
+            message: "could not parse version".to_string(),
         };
     };
 
-    if installed_version.semver < VALGRIND_CODSPEED_VERSION {
-        return ToolStatus {
-            tool_name,
-            status: ToolInstallStatus::IncorrectVersion {
-                version,
-                message: format!(
-                    "version too old, expecting {} or higher",
-                    VALGRIND_CODSPEED_VERSION_STRING.as_str()
-                ),
-            },
+    // Legacy `.codspeed` builds (no iteration suffix) predate iteration
+    // tracking, so they count as iteration 0.
+    let installed_iteration = installed_version.codspeed_iteration.unwrap_or(0);
+    let is_version_outdated = (installed_version.semver, installed_iteration)
+        < (VALGRIND_CODSPEED_VERSION, VALGRIND_CODSPEED_ITERATION);
+    if is_version_outdated {
+        return ToolInstallStatus::IncorrectVersion {
+            version,
+            message: format!(
+                "version too old, expecting {} or higher",
+                VALGRIND_CODSPEED_VERSION_STRING.as_str()
+            ),
         };
     }
 
-    ToolStatus {
-        tool_name,
-        status: ToolInstallStatus::Installed { version },
-    }
+    ToolInstallStatus::Installed { version }
 }
 
 fn is_valgrind_installed() -> bool {
@@ -330,6 +332,57 @@ mod tests {
         assert_ne!(v1, v2);
     }
 
+    #[test]
+    fn test_classify_same_version_older_iteration_is_rejected() {
+        // Pinned is 3.26.0-0codspeed3: a cached 3.26.0.codspeed2 build is the
+        // same upstream valgrind but an older repackaging, so it must be
+        // rejected and reinstalled.
+        let status = classify_valgrind_version("valgrind-3.26.0.codspeed2".to_string());
+        assert!(
+            matches!(status, ToolInstallStatus::IncorrectVersion { .. }),
+            "stale codspeed iteration must be rejected, got: Installed"
+        );
+    }
+
+    #[test]
+    fn test_classify_legacy_suffix_with_pinned_semver_is_rejected() {
+        // Old builds report just `.codspeed` (no iteration); for the pinned
+        // upstream version they predate the pinned iteration.
+        let version = format!("valgrind-{VALGRIND_CODSPEED_VERSION}.codspeed");
+        let status = classify_valgrind_version(version);
+        assert!(matches!(status, ToolInstallStatus::IncorrectVersion { .. }));
+    }
+
+    #[test]
+    fn test_classify_pinned_iteration_is_installed() {
+        let version =
+            format!("valgrind-{VALGRIND_CODSPEED_VERSION}.codspeed{VALGRIND_CODSPEED_ITERATION}");
+        let status = classify_valgrind_version(version);
+        assert!(matches!(status, ToolInstallStatus::Installed { .. }));
+    }
+
+    #[test]
+    fn test_classify_newer_iteration_is_installed() {
+        let version = format!(
+            "valgrind-{VALGRIND_CODSPEED_VERSION}.codspeed{}",
+            VALGRIND_CODSPEED_ITERATION + 1
+        );
+        let status = classify_valgrind_version(version);
+        assert!(matches!(status, ToolInstallStatus::Installed { .. }));
+    }
+
+    #[test]
+    fn test_classify_newer_semver_with_legacy_suffix_is_installed() {
+        let status = classify_valgrind_version("valgrind-3.99.0.codspeed".to_string());
+        assert!(matches!(status, ToolInstallStatus::Installed { .. }));
+    }
+
+    #[test]
+    fn test_classify_non_codspeed_build_is_rejected() {
+        let status = classify_valgrind_version("valgrind-3.26.0".to_string());
+        assert!(matches!(status, ToolInstallStatus::IncorrectVersion { .. }));
+    }
+
     #[test]
     fn test_parse_valgrind_codspeed_version_invalid_format() {
         assert_eq!(