Patch every registry index copy of a crate

A shared CARGO_HOME keeps one extracted copy of a crate per registry
index dir: cargo 1.70-1.84 and cargo 1.85+ each unpack and build their
own. Agent mode only patched, checked and restored the copy in the
first dir, so a project built by the other cargo kept compiling the
unpatched crate while apply reported success and vex attested
not_affected.

Carry every copy the crawler finds, so apply patches them all,
apply --check and vex fail on an unpatched one, and rollback restores
each one.

Fixes #339

Assisted-by: Claude Code:claude-opus-5-5

Author: claude

crates/socket-patch-cli/src/ecosystem_dispatch.rs

@@ -228,8 +228,8 @@ fn push_path(out: &mut HashMap<String, Vec<PathBuf>>, purl: String, path: PathBu
     }
 }
 
-/// Default merge for the single-copy ecosystems (cargo / go / composer /
-/// nuget / deno): keep the FIRST path discovered per PURL, matching the
+/// Default merge for the single-copy ecosystems (go / composer / nuget /
+/// deno): keep the FIRST path discovered per PURL, matching the
 /// historical `HashMap<String, PathBuf>` first-wins contract exactly. These
 /// ecosystems resolve one logical install per `name@version`, but the same
 /// install is legitimately reachable from several source roots (e.g. NuGet's
@@ -277,6 +277,26 @@ fn merge_variant_copies(
     }
 }
 
+/// Cargo merge: keep EVERY distinct copy, one per source root. Each root
+/// of the shared registry cache is one registry index dir
+/// (`index.crates.io-6f17d22bba15001f` for cargo 1.70–1.84,
+/// `index.crates.io-1949cf8c6b5b557f` for cargo ≥ 1.85, the pre-1.70 git
+/// index), and each holds its own extracted copy that a different cargo
+/// builds from. First-wins patched, checked and restored only the copy in
+/// the first dir in listing order, so a project on the other cargo kept
+/// building the unpatched crate while `apply` reported success and `vex`
+/// attested it (#339). A `cargo vendor` tree or `--global-prefix` is a
+/// single root, so it still yields one copy.
+fn merge_cargo_copies(
+    out: &mut HashMap<String, Vec<PathBuf>>,
+    _purls: &[String],
+    packages: HashMap<String, CrawledPackage>,
+) {
+    for (purl, pkg) in packages {
+        push_path(out, purl, pkg.path);
+    }
+}
+
 /// npm merge: the npm crawler returns EVERY physical copy of each PURL
 /// (nested duplicates, diamonds, `file:` dups), so fold every path in.
 /// A one-path `HashMap<String, PathBuf>` would silently drop every copy
@@ -430,7 +450,8 @@ async fn dispatch_find(
         using_label = "cargo crate sources",
         err_label = "Cargo crates",
         purls_override = passthrough_purls,
-        on_match = merge_first_wins,
+        // One copy per registry index dir, each built by another cargo.
+        on_match = merge_cargo_copies,
     );
 
     scan_ecosystem!(
@@ -559,7 +580,8 @@ pub async fn find_all_packages_for_purls(
     // (base-PURL keyed) instead of first-wins: the gem crawler surfaces
     // coexisting bundler stores whose copies apply must ALL patch. The
     // rollback variant below gets the same multi-copy carry from
-    // `merge_qualified`'s `push_path`. Single-copy ecosystems keep true
+    // `merge_qualified`'s `push_path`. Cargo keeps every registry index
+    // copy (`merge_cargo_copies`); the single-copy ecosystems keep true
     // first-wins via their own `merge_first_wins` wiring in
     // `dispatch_find`.
     dispatch_find(partitioned, options, silent, merge_variant_copies, None).await
@@ -1283,6 +1305,34 @@ mod tests {
         );
     }
 
+    // ---- merge_cargo_copies ------------------------------------------------
+
+    #[test]
+    fn merge_cargo_copies_keeps_every_registry_index_copy() {
+        // #339: the macro calls on_match once per registry index dir; each
+        // dir's copy is built by a different cargo, so all are carried in
+        // discovery order, and a path re-observed is recorded once.
+        let mut out: HashMap<String, Vec<PathBuf>> = HashMap::new();
+        for path in [
+            "/src/index-1949cf/cfg-if-1.0.0",
+            "/src/index-6f17d2/cfg-if-1.0.0",
+        ] {
+            merge_cargo_copies(&mut out, &[], packages(&[("pkg:cargo/cfg-if@1.0.0", path)]));
+        }
+        merge_cargo_copies(
+            &mut out,
+            &[],
+            packages(&[("pkg:cargo/cfg-if@1.0.0", "/src/index-6f17d2/cfg-if-1.0.0")]),
+        );
+        assert_eq!(
+            out.get("pkg:cargo/cfg-if@1.0.0"),
+            Some(&vec![
+                PathBuf::from("/src/index-1949cf/cfg-if-1.0.0"),
+                PathBuf::from("/src/index-6f17d2/cfg-if-1.0.0"),
+            ])
+        );
+    }
+
     // ---- merge_variant_copies ----------------------------------------------
 
     #[test]

crates/socket-patch-cli/tests/e2e_cargo.rs

@@ -552,3 +552,154 @@ async fn sync_keeps_shared_cache_entry_behind_a_cargo_vendor_dir() {
     );
     assert_eq!(std::fs::read(itoa_old.join("src/lib.rs")).unwrap(), orig);
 }
+
+/// #339: `$CARGO_HOME/registry/src` holds one extracted copy of a crate
+/// per registry index dir (`index.crates.io-6f17d22bba15001f` for cargo
+/// 1.70–1.84, `index.crates.io-1949cf8c6b5b557f` for cargo ≥ 1.85), so
+/// two toolchains sharing a `CARGO_HOME` each build their own copy. Agent
+/// mode must patch, check, attest and restore EVERY copy, not just the
+/// first index dir in listing order: otherwise the project built by the
+/// other cargo compiles the unpatched crate while `apply` reports success
+/// and `vex` attests `not_affected`.
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn agent_mode_covers_every_registry_index_copy() {
+    let server = start_proxy().await;
+    let proxy_url = server.uri();
+    let dir = tempfile::tempdir().unwrap();
+    let root = dir.path();
+    let cwd = root.to_str().unwrap();
+
+    std::fs::write(
+        root.join("Cargo.toml"),
+        "[package]\nname = \"myapp\"\nversion = \"0.1.0\"\n\n[dependencies]\ncfg-if = \"=1.0.0\"\n",
+    )
+    .unwrap();
+    std::fs::write(
+        root.join("Cargo.lock"),
+        "version = 3\n\n[[package]]\nname = \"cfg-if\"\nversion = \"1.0.0\"\n\
+         source = \"registry+https://github.com/rust-lang/crates.io-index\"\n\n\
+         [[package]]\nname = \"myapp\"\nversion = \"0.1.0\"\ndependencies = [\n \"cfg-if\",\n]\n",
+    )
+    .unwrap();
+
+    let orig: &[u8] = b"pub fn cfg() {}\n";
+    let patched: &[u8] = b"pub fn cfg() {}\npub fn socket_patched() {}\n";
+    let src = root.join(".cargo/registry/src");
+    let copies = [
+        fake_registry_crate(
+            &src.join("index.crates.io-1949cf8c6b5b557f"),
+            "cfg-if",
+            "1.0.0",
+            orig,
+        ),
+        fake_registry_crate(
+            &src.join("index.crates.io-6f17d22bba15001f"),
+            "cfg-if",
+            "1.0.0",
+            orig,
+        ),
+    ];
+    let lib = |copy: &PathBuf| std::fs::read(copy.join("src/lib.rs")).unwrap();
+
+    let socket = root.join(".socket");
+    let purl = "pkg:cargo/cfg-if@1.0.0";
+    let manifest = serde_json::json!({ "patches": {
+        purl: manifest_record(&socket, "33900000-0000-4000-8000-000000000001", orig, patched),
+    }});
+    std::fs::write(
+        socket.join("manifest.json"),
+        serde_json::to_string_pretty(&manifest).unwrap(),
+    )
+    .unwrap();
+
+    // apply patches both copies.
+    let out = run(
+        &["apply", "--json", "--offline", "--cwd", cwd],
+        root,
+        &proxy_url,
+    )
+    .await;
+    let stdout = String::from_utf8_lossy(&out.stdout);
+    let stderr = String::from_utf8_lossy(&out.stderr);
+    assert!(
+        out.status.success(),
+        "apply must exit 0\nstdout:\n{stdout}\nstderr:\n{stderr}"
+    );
+    for copy in &copies {
+        assert_eq!(
+            lib(copy),
+            patched,
+            "apply left {} unpatched\nstdout:\n{stdout}",
+            copy.display()
+        );
+    }
+
+    // A copy re-extracted pristine (another cargo fetched it again) must
+    // fail the CI gate instead of reading as in sync.
+    std::fs::write(copies[1].join("src/lib.rs"), orig).unwrap();
+    let out = run(
+        &["apply", "--check", "--json", "--offline", "--cwd", cwd],
+        root,
+        &proxy_url,
+    )
+    .await;
+    let stdout = String::from_utf8_lossy(&out.stdout);
+    assert!(
+        !out.status.success(),
+        "apply --check must fail while {} is unpatched\nstdout:\n{stdout}",
+        copies[1].display()
+    );
+
+    // ... and must keep vex from attesting the patch.
+    let out = run(
+        &[
+            "vex",
+            "--offline",
+            "--product",
+            "pkg:cargo/myapp@0.1.0",
+            "--cwd",
+            cwd,
+        ],
+        root,
+        &proxy_url,
+    )
+    .await;
+    let stdout = String::from_utf8_lossy(&out.stdout);
+    let stderr = String::from_utf8_lossy(&out.stderr);
+    assert!(
+        !stdout.contains("not_affected"),
+        "vex attested a patch one built copy lacks\nstdout:\n{stdout}\nstderr:\n{stderr}"
+    );
+
+    // Re-apply fixes the pristine copy; rollback then restores both.
+    let out = run(
+        &["apply", "--json", "--offline", "--cwd", cwd],
+        root,
+        &proxy_url,
+    )
+    .await;
+    assert!(out.status.success(), "re-apply must exit 0");
+    for copy in &copies {
+        assert_eq!(lib(copy), patched, "re-apply left {}", copy.display());
+    }
+    let out = run(
+        &["rollback", purl, "--json", "--offline", "--cwd", cwd],
+        root,
+        &proxy_url,
+    )
+    .await;
+    let stdout = String::from_utf8_lossy(&out.stdout);
+    let stderr = String::from_utf8_lossy(&out.stderr);
+    assert!(
+        out.status.success(),
+        "rollback must exit 0\nstdout:\n{stdout}\nstderr:\n{stderr}"
+    );
+    for copy in &copies {
+        assert_eq!(
+            lib(copy),
+            orig,
+            "rollback left {} patched\nstdout:\n{stdout}",
+            copy.display()
+        );
+    }
+}

crates/socket-patch-cli/tests/in_process_rollback_all_ecosystems.rs

@@ -26,7 +26,7 @@
 //! merge functions behave identically, so the test would prove nothing.
 //!
 //! npm / cargo / golang / composer / nuget are NOT release-variant
-//! ecosystems (their crawlers wire `merge_first_wins` in both resolvers), so a
+//! ecosystems (their crawlers wire a fixed merge in both resolvers), so a
 //! qualified PURL there is genuinely unsupported and those fixtures keep
 //! bare PURLs.
 

docs/ecosystems.md

@@ -1099,6 +1099,12 @@ crate that means the **shared** `$CARGO_HOME/registry` cache: the patch affects
 project on the machine, and is silently reset by `cargo clean` or a cache prune. Use
 `--mode vendored` for a project-local, committable patch.
 
+The cache holds one extracted copy of a crate per registry index directory under
+`registry/src` (cargo 1.70–1.84 and cargo 1.85+ use different ones), so two toolchains
+sharing a `CARGO_HOME` each build their own copy. `apply`, `apply --check`, `vex` and
+`rollback` cover every copy: an unpatched one fails the check and keeps `vex` from
+attesting the patch.
+
 Nothing deletes a crate from the cache when the project stops using it, so the
 manifest record stays the only way to restore that copy: `rollback` (and `remove`)
 also restore it after the crate was moved to vendored mode, and `scan --prune` /