Expect one yarn reader's warning outside the root

A yarn classic file: directory copy outside the project root is now
named by the yarn rewriter, with the same
redirect_yarn_classic_directory_skipped warning an in-root copy gets,
instead of the engine's generic redirect_copy_unpatched fallback. The
e2e now asserts that code, and that the copy is named exactly once.
The rewriter test's doc says what it compares: which package the copy
holds.

Refs #1951

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

Author: claude

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

@@ -1542,9 +1542,10 @@ async fn classic_file_directory_copy_under_another_name_is_named_and_not_atteste
 /// #1516: the #1236 copy, but from a directory OUTSIDE the project root
 /// (`"lp2": "file:../ext/lpdir"`, shared code in a non-workspace
 /// monorepo). yarn 1 installs it into `node_modules/lp2` all the same, so
-/// it stays unpatched. `scan --mode hosted` must name the copy
-/// (`redirect_copy_unpatched`), and neither its in-run VEX nor a lock-only
-/// `vex` may attest left-pad not_affected.
+/// it stays unpatched. `scan --mode hosted` must name the copy exactly as
+/// it names an in-root one (`redirect_yarn_classic_directory_skipped`,
+/// read through the reader vendored and VEX use, #1951), once, and neither
+/// its in-run VEX nor a lock-only `vex` may attest left-pad not_affected.
 #[tokio::test(flavor = "multi_thread")]
 #[serial_test::serial]
 async fn classic_outside_root_copy_under_another_name_is_named_and_not_attested() {
@@ -1635,11 +1636,22 @@ async fn classic_outside_root_copy_under_another_name_is_named_and_not_attested(
         lock.contains(&format!("{UUID}/{DEP}-{DEP_VERSION}.tgz")),
         "the registry left-pad block must still be pinned:\n{lock}"
     );
-    assert!(
-        env.to_string().contains("redirect_copy_unpatched"),
-        "the outside-root copy must be named: {env}"
+    let naming: Vec<&str> = env["warnings"]
+        .as_array()
+        .into_iter()
+        .flatten()
+        .filter(|w| {
+            w["detail"]
+                .as_str()
+                .is_some_and(|d| d.contains("lp2@file:../ext/lpdir"))
+        })
+        .filter_map(|w| w["code"].as_str())
+        .collect();
+    assert_eq!(
+        naming,
+        ["redirect_yarn_classic_directory_skipped"],
+        "the outside-root copy must be named once, as an in-root one is: {env}"
     );
-    assert!(env.to_string().contains("lp2@file:../ext/lpdir"), "{env}");
     let vex = std::fs::read_to_string(proj.join("out.vex.json")).unwrap_or_default();
     assert!(
         !vex.contains("not_affected"),

crates/socket-patch-core/src/patch/redirect/mod.rs

@@ -13751,10 +13751,12 @@ mod tests {
         }
     }
 
-    /// #1951: the hosted rewriter names a yarn classic `file:` / url copy
-    /// through the same reader vendored and VEX use
-    /// ([`crate::formats::yarn::copy::classic_copy_ref`]), so the modes
-    /// make the same decision for every copy. yarn 1 installs
+    /// #1951: the hosted rewriter reads which package a yarn classic
+    /// `file:` / url copy holds through the same reader vendored and VEX use
+    /// ([`crate::formats::yarn::copy::classic_copy_ref`] and
+    /// [`crate::formats::yarn::copy::CopyRef::identity`]), so the modes
+    /// identify the same copies. (A copy no reader identifies is a separate
+    /// rule: vendored keeps it as a possible copy, #1516.) yarn 1 installs
     /// `file:../ext/lpdir` from outside the root as readily as from inside
     /// it, so that copy is read and named; an absolute `file:` path is never
     /// read (a lock is untrusted input, #1516); a codeload tarball names no
@@ -13792,7 +13794,7 @@ mod tests {
                 false,
             ),
         ] {
-            // What vendored and VEX decide for this copy.
+            // The package vendored and VEX identify this copy as.
             let pats = vec![patterns.to_string()];
             let vendored = classic_copy_ref(&pats, resolved).and_then(|copy| {
                 let bytes = copy