@@ -1247,6 +1247,134 @@ async fn classic_file_directory_dependency_is_named_and_not_attested() {
     );
 }
 
+/// #1236: the same `file:` directory declared under ANOTHER dependency
+/// name (`"lp2": "file:./lpdir"`, lpdir being left-pad@1.3.0) locks as
+/// `"lp2@file:./lpdir"`, beside the registry left-pad. yarn 1 copies it
+/// into `node_modules/lp2`, so it stays unpatched whatever the pin does.
+/// `scan --mode hosted` must still pin the registry block, name the copy
+/// (`redirect_yarn_classic_directory_skipped`), 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_file_directory_copy_under_another_name_is_named_and_not_attested() {
+    if !require_yarn_classic("e2e_redirect_yarn_classic_build (other-name file:)", |c| {
+        cache_env::isolate(c);
+    }) {
+        return;
+    }
+    let tmp = tempfile::tempdir().unwrap();
+    let proj = tmp.path().join("proj");
+    let copy = proj.join("lpdir");
+    std::fs::create_dir_all(&copy).unwrap();
+    std::fs::write(
+        copy.join("package.json"),
+        format!(r#"{{"name":"{DEP}","version":"{DEP_VERSION}","main":"index.js"}}"#),
+    )
+    .unwrap();
+    let orig: &[u8] = b"module.exports = function leftPad(s) { return s; };\n";
+    std::fs::write(copy.join("index.js"), orig).unwrap();
+    std::fs::write(
+        proj.join("package.json"),
+        format!(
+            r#"{{"name":"other-name-classic","version":"0.0.0","private":true,"dependencies":{{"{DEP}":"{DEP_VERSION}","lp2":"file:./lpdir"}}}}"#
+        ),
+    )
+    .unwrap();
+    let cache = tmp.path().join("yarn-cache");
+    let install = corepack(
+        &proj,
+        &yarn_classic(),
+        &["install", "--no-progress"],
+        &[("YARN_CACHE_FOLDER", cache.to_str().unwrap())],
+    );
+    if !install.status.success() {
+        skip!(
+            "(other-name file:): fixture `yarn install` failed:\n{}",
+            String::from_utf8_lossy(&install.stderr)
+        );
+        return;
+    }
+    let lock_pristine = std::fs::read_to_string(proj.join("yarn.lock")).unwrap();
+    assert!(
+        lock_pristine.contains("lp2@file:./lpdir"),
+        "fixture must lock the copy under its dependency name:\n{lock_pristine}"
+    );
+
+    let installed_dir = proj.join("node_modules").join(DEP);
+    let installed_orig = std::fs::read(installed_dir.join("index.js")).unwrap();
+    let patched: Vec<u8> = [MARKER.as_bytes(), &installed_orig].concat();
+    let tgz_path = tmp.path().join("patched.tgz");
+    build_patched_tgz(&installed_dir, &patched, &tgz_path);
+    let tgz = std::fs::read(&tgz_path).unwrap();
+    let server = mock_hosted_grant(&tgz, &installed_orig, &patched, "other-name fixture").await;
+
+    let api_url = server.uri();
+    let api = [
+        "--api-url",
+        api_url.as_str(),
+        "--org",
+        ORG,
+        "--api-token",
+        "fake",
+    ];
+    let mut args = vec![
+        "scan",
+        "--mode",
+        "hosted",
+        "--json",
+        "--yes",
+        "--cwd",
+        proj.to_str().unwrap(),
+        "--vex",
+        "out.vex.json",
+        "--vex-product",
+        PRODUCT,
+    ];
+    args.extend(api);
+    let (code, stdout, stderr) = run_socket(&proj, &args);
+    println!("scan exit {code}\nstdout:\n{stdout}\nstderr:\n{stderr}");
+    let env: serde_json::Value = serde_json::from_str(&stdout)
+        .unwrap_or_else(|e| panic!("scan --json output is not JSON: {e}\n{stdout}\n{stderr}"));
+    let lock = std::fs::read_to_string(proj.join("yarn.lock")).unwrap();
+    assert!(
+        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_yarn_classic_directory_skipped"),
+        "the other-name copy must be named: {env}"
+    );
+    assert!(env.to_string().contains("lp2@file:./lpdir"), "{env}");
+    let vex = std::fs::read_to_string(proj.join("out.vex.json")).unwrap_or_default();
+    assert!(
+        !vex.contains("not_affected"),
+        "the in-run VEX must not attest left-pad:\n{vex}\n{env}"
+    );
+
+    // Lock-only: with node_modules gone, `vex` reads only the lock.
+    std::fs::remove_dir_all(proj.join("node_modules")).unwrap();
+    let mut args = vec![
+        "vex",
+        "--cwd",
+        proj.to_str().unwrap(),
+        "--output",
+        "lock-only.vex.json",
+        "--product",
+        PRODUCT,
+        "--patch-server-url",
+        api_url.as_str(),
+    ];
+    args.extend(api);
+    let (code, stdout, stderr) = run_socket(&proj, &args);
+    println!("vex exit {code}\nstdout:\n{stdout}\nstderr:\n{stderr}");
+    let vex = std::fs::read_to_string(proj.join("lock-only.vex.json")).unwrap_or_default();
+    assert!(
+        !vex.contains("not_affected"),
+        "lock-only vex must not attest left-pad:\n{vex}\n{stdout}\n{stderr}"
+    );
+}
+
 /// A mock patch API granting one hosted patch of `DEP@DEP_VERSION` whose
 /// tarball is `tgz` (`index.js` from `orig` to `patched`).
 async fn mock_hosted_grant(tgz: &[u8], orig: &[u8], patched: &[u8], title: &str) -> MockServer {
 
@@ -74,6 +74,95 @@ pub(crate) fn classic_copy_source(patterns: &[String], resolved: Option<&str>) -
     }
 }
 
+/// The root-relative `file:` directory a classic block's key names, if
+/// any: yarn 1 COPIES it into node_modules under the DEPENDENCY name
+/// (`"lp2@file:./lpdir"`), so which package that copy is comes from the
+/// directory's own `package.json` (#1236). `None` for a `file:` tarball or
+/// a path that leaves the root.
+pub(crate) fn classic_file_directory(patterns: &[String]) -> Option<String> {
+    patterns.iter().find_map(|p| {
+        let path = split_pattern(p)?.1.strip_prefix("file:")?;
+        let path = path.split('#').next().unwrap_or_default();
+        if is_tarball_path(path) {
+            return None;
+        }
+        crate::utils::cargo_workspace::normalize_rel("", path)
+    })
+}
+
+/// The package a classic `file:` directory or url copy really installs,
+/// whatever dependency name its key carries (#1236): the directory's
+/// `package.json` `name` (read through `read_text`, given the
+/// root-relative manifest path), or the registry package a url tarball's
+/// path names. `None` when neither says (a `file:` tarball, a
+/// non-registry url, an unreadable manifest).
+pub(crate) fn classic_copy_real_name(
+    patterns: &[String],
+    resolved: Option<&str>,
+    version: &str,
+    read_text: impl Fn(&str) -> Option<String>,
+) -> Option<(String, CopySource)> {
+    match classic_copy_source(patterns, resolved) {
+        CopySource::Directory => {
+            let dir = classic_file_directory(patterns)?;
+            let manifest = if dir.is_empty() {
+                "package.json".to_string()
+            } else {
+                format!("{dir}/package.json")
+            };
+            let name = manifest_name(read_text(&manifest)?.as_bytes())?;
+            Some((name, CopySource::Directory))
+        }
+        CopySource::RemoteTarball => {
+            let url = resolved?.split('#').next().unwrap_or_default();
+            if !url.starts_with("http") {
+                return None;
+            }
+            Some((
+                registry_tarball_name(url, version)?,
+                CopySource::RemoteTarball,
+            ))
+        }
+        _ => None,
+    }
+}
+
+/// `name` of a `package.json`.
+pub(crate) fn manifest_name(bytes: &[u8]) -> Option<String> {
+    let bytes = crate::formats::text::strip_bom_bytes(bytes);
+    serde_json::from_slice::<serde_json::Value>(bytes)
+        .ok()?
+        .get("name")?
+        .as_str()
+        .map(str::to_string)
+}
+
+/// The package an npm registry tarball url serves, from its
+/// `/<name>/-/<leaf>-<version>.tgz` path (`<name>` may be `@scope/leaf`,
+/// its `@` / `/` possibly percent-encoded); `None` for any other shape.
+pub(crate) fn registry_tarball_name(url: &str, version: &str) -> Option<String> {
+    let path = url.split_once("://").map_or(url, |(_, rest)| rest);
+    let path = path.split(['?']).next()?;
+    let (before, file) = path.rsplit_once("/-/")?;
+    let mut segs: Vec<String> = before
+        .split('/')
+        .skip(1) // the host
+        .map(|seg| crate::utils::purl::percent_decode_purl_component(seg).into_owned())
+        .collect();
+    let leaf_name = segs.pop()?;
+    let (scope, leaf_name) = match leaf_name.split_once('/') {
+        Some((scope, leaf)) => (Some(scope.to_string()), leaf.to_string()),
+        None => (segs.pop().filter(|s| s.starts_with('@')), leaf_name),
+    };
+    if file != format!("{leaf_name}-{version}.tgz") {
+        return None;
+    }
+    Some(match scope {
+        Some(scope) => format!("{scope}/{leaf_name}"),
+        None => leaf_name,
+    })
+}
+
 /// A GitHub codeload tarball: what yarn 1 locks a hosted-git shorthand to.
 fn is_codeload_tarball(resolved: &str) -> bool {
     resolved
 
@@ -590,6 +590,35 @@ pub async fn read_candidate_files(
         out.read(view, unreadable, crate::patch::redirect::YARNRC_REL)
             .await;
         out.read(view, unreadable, NPMRC_REL).await;
+        // A `file:` directory copy is locked under the DEPENDENCY name, so
+        // the classic rewriter reads which package it is from the
+        // directory's `package.json` (#1236). Advisory: never rewritten,
+        // and an unreadable one only leaves that copy unnamed.
+        let dirs: BTreeSet<String> = out
+            .files
+            .get("yarn.lock")
+            .map(|lock| {
+                crate::vendor::lock_inventory::yarn::classic_entries(lock)
+                    .iter()
+                    .filter_map(|e| {
+                        crate::formats::yarn::source::classic_file_directory(&e.patterns)
+                    })
+                    .collect()
+            })
+            .unwrap_or_default();
+        for dir in dirs {
+            let rel = if dir.is_empty() {
+                "package.json".to_string()
+            } else {
+                format!("{dir}/package.json")
+            };
+            if out.files.contains_key(&rel) {
+                continue;
+            }
+            if let Some(text) = read_advisory(view, unreadable, &rel).await {
+                out.files.insert(rel, text);
+            }
+        }
     }
 
     // Cargo workspace members (and in-root path dependencies) declare