@@ -5325,6 +5325,89 @@ async fn yarn_berry_rollback_keeps_a_bare_locator_for_conventional_urls() {
     assert!(!restored.contains("__archiveUrl"), "{restored}");
 }
 
+/// #1082: a descriptor added after pinning (a workspace member's plain
+/// `NAME: VERSION`, or an `npm:` alias) gets its own registry entry beside
+/// the hosted one. `rollback` and `remove` restore the hosted entry into
+/// that entry, the way yarn merges two entries with one resolution, so a
+/// fresh `yarn install --immutable` accepts the lock; two blocks sharing a
+/// `resolution:` fail it with YN0028.
+#[tokio::test]
+#[serial]
+async fn yarn_berry_unwind_merges_into_a_registry_entry_added_after_pinning() {
+    let server = MockServer::start().await;
+    mock_discovery(&server).await;
+    let hosted_url = HOSTED_URL.replace("http://patch.test", &server.uri());
+    mock_reference_with_berry_url(&server, &hosted_url).await;
+    mock_view(&server).await;
+    mock_npm_registry_advertising(
+        &server,
+        &vlt_hosted_common::sha512_sri(&upstream_tarball()),
+        &format!(
+            "{}/npm-registry/{NAME}/-/{NAME}-{VERSION}.tgz",
+            server.uri()
+        ),
+    )
+    .await;
+    let checksum = socket_patch_core::vendor::test_support::service_fixture::berry_checksum(
+        &upstream_tarball(),
+        NAME,
+    )
+    .unwrap();
+    let block = |key: &str| {
+        format!(
+            "\n{key}:\n  version: {VERSION}\n  resolution: \"{NAME}@npm:{VERSION}\"\n  \
+             checksum: {checksum}\n  languageName: node\n  linkType: hard\n"
+        )
+    };
+    let plain = format!("\"{NAME}@npm:{VERSION}\"");
+    let alias = format!("\"lp@npm:{NAME}@{VERSION}\"");
+    for (added, merged) in [
+        (
+            plain.clone(),
+            format!("\"{NAME}@npm:{VERSION}, {NAME}@npm:^{VERSION}\":"),
+        ),
+        (
+            alias.clone(),
+            format!("\"{NAME}@npm:^{VERSION}, lp@npm:{NAME}@{VERSION}\":"),
+        ),
+    ] {
+        for command in ["rollback", "remove"] {
+            let tmp = tempfile::tempdir().unwrap();
+            write_berry_project(tmp.path());
+            let env = run_redirect_subprocess_with(
+                tmp.path(),
+                &server.uri(),
+                &["--patch-server-url", &server.uri()],
+            );
+            assert_eq!(vlt_hosted_common::redirected(&env), 1, "{env:#}");
+            let lock_path = tmp.path().join("yarn.lock");
+            let pinned = std::fs::read_to_string(&lock_path).unwrap();
+            std::fs::write(&lock_path, format!("{pinned}{}", block(&added))).unwrap();
+
+            let args: &[&str] = if command == "rollback" {
+                &["rollback"]
+            } else {
+                &["remove", PURL]
+            };
+            let (code, env) = hosted_unwind_json(tmp.path(), &server, &server.uri(), args);
+            assert_eq!(code, Some(0), "{command} {added}: {env:#}");
+            let restored = std::fs::read_to_string(&lock_path).unwrap();
+            assert_eq!(
+                restored
+                    .matches(&format!("resolution: \"{NAME}@npm:{VERSION}\""))
+                    .count(),
+                1,
+                "{command} {added}: one entry per resolution:\n{restored}"
+            );
+            assert_eq!(restored.matches(&merged).count(), 1, "{restored}");
+            assert!(!restored.contains(&format!("\n{added}:")), "{restored}");
+            assert!(!restored.contains(&hosted_url), "{restored}");
+            let pkg = std::fs::read_to_string(tmp.path().join("package.json")).unwrap();
+            assert!(!pkg.contains("resolutions"), "{pkg}");
+        }
+    }
+}
+
 /// #908: the restore reads `dist.tarball` from the registry the project
 /// resolves against (`.yarnrc.yml` `npmRegistryServer`), not from the
 /// default registry. A mirror whose tarball URLs are off the conventional
 
@@ -4707,6 +4707,18 @@ fn rewrite_yarn_berry_with_manifests(
             });
             continue;
         }
+        // #1082: a descriptor added after pinning, which no selector routes,
+        // gets its own registry entry beside the one an earlier hosted run
+        // keyed by its tarball URL; the pin is what keeps yarn from merging
+        // them. Folding it in (one more selector, its entry dropped) is what
+        // yarn writes once the selector exists.
+        let mut folded: Vec<(usize, Vec<String>)> = Vec::new();
+        if targets.len() > 1 && targets.iter().filter(|(_, r)| r.is_empty()).count() == 1 {
+            let (url_entry, registry): (Vec<_>, Vec<_>) =
+                targets.drain(..).partition(|(_, r)| r.is_empty());
+            targets = url_entry;
+            folded = registry;
+        }
         if targets.len() > 1 {
             result.warnings.push(RewriteWarning {
                 code: "redirect_yarn_berry_ambiguous_entry".into(),
@@ -4786,6 +4798,10 @@ fn rewrite_yarn_berry_with_manifests(
             &fname,
             &dep.version,
             &key_ranges,
+            &folded
+                .iter()
+                .flat_map(|(_, ranges)| ranges.iter().cloned())
+                .collect::<Vec<_>>(),
             current_url.as_deref(),
             &dep.artifact_url,
         ) {
@@ -4821,6 +4837,9 @@ fn rewrite_yarn_berry_with_manifests(
         )
         .join("\n");
         cut.extend(cut_descriptors(&block, &rewritten));
+        for (idx, _) in &folded {
+            cut.extend(cut_descriptors(&blocks[*idx], &rewritten));
+        }
         for (selector, original) in pin.apply(manifest_obj, &dep.artifact_url) {
             manifest_changed = true;
             result.edits.push(FileEdit {
@@ -4853,6 +4872,20 @@ fn rewrite_yarn_berry_with_manifests(
             moved_keys.push(new_key);
             changed = true;
         }
+        // Highest index first, so the lower ones stay valid.
+        folded.sort_by_key(|(idx, _)| std::cmp::Reverse(*idx));
+        for (idx, _) in folded {
+            let removed = blocks.remove(idx);
+            result.edits.push(FileEdit {
+                path: "yarn.lock".into(),
+                kind: "redirect_yarn_berry_entry_folded".into(),
+                action: "removed".into(),
+                key: stanza_key(&removed).map(|k| k.trim_matches('"').to_string()),
+                original: Some(Value::String(doc.on_disk(&removed).into_owned())),
+                new: None,
+            });
+            changed = true;
+        }
         result
             .confirmed_yarn_berry_uuids
             .insert(dep.patch_uuid.clone());
@@ -4915,6 +4948,7 @@ fn rewrite_yarn_berry_with_manifests(
                     result.edits.retain(|e| {
                         e.kind != "redirect_yarn_berry_entry"
                             && e.kind != "redirect_yarn_berry_entry_pruned"
+                            && e.kind != "redirect_yarn_berry_entry_folded"
                             && e.kind != "redirect_yarn_berry_resolution"
                     });
                     for dep in &npm {
@@ -5081,6 +5115,7 @@ fn berry_resolutions_pin(
     name: &str,
     version: &str,
     key_ranges: &[String],
+    folded_ranges: &[String],
     current_url: Option<&str>,
     artifact_url: &str,
 ) -> Result<BerryResolutionsPin, RewriteWarning> {
@@ -5137,6 +5172,13 @@ fn berry_resolutions_pin(
             ),
         });
     }
+    // The registry entries of descriptors added after pinning (#1082).
+    for range in folded_ranges {
+        let selector = format!("{name}@{range}");
+        if !selectors.contains(&selector) {
+            selectors.push(selector);
+        }
+    }
     let ranges: Vec<&str> = selectors
         .iter()
         .filter_map(|selector| crate::formats::yarn::patterns::split_pattern(selector))
@@ -10520,6 +10562,83 @@ mod tests {
         );
     }
 
+    /// #1082: a descriptor added after pinning (a workspace member's
+    /// `left-pad: 1.3.0`) gets its own registry entry beside the hosted
+    /// one, because no selector routes it. A re-run folds it into the pin:
+    /// one more selector, the registry entry gone, the URL entry kept. A
+    /// superseding uuid folds it the same way.
+    #[test]
+    fn yarn_berry_rerun_folds_a_descriptor_added_after_pinning() {
+        let checksum = format!("10c0/{}", "7".repeat(128));
+        let url = berry_hosted_url("left-pad", "left-pad", "1.3.0");
+        let ovr = berry_override("left-pad", "1.3.0", &url, &checksum);
+        let mut first = RewriteResult::default();
+        rewrite_yarn_berry(
+            &berry_files(berry_lock("10c0"), berry_manifest()),
+            std::slice::from_ref(&ovr),
+            &mut first,
+        );
+        let registry_block = format!(
+            "\n\"left-pad@npm:1.3.0\":\n  version: 1.3.0\n  resolution: \"left-pad@npm:1.3.0\"\n  \
+             checksum: 10c0/{}\n  languageName: node\n  linkType: hard\n",
+            "3".repeat(128)
+        );
+        let drifted = berry_files(
+            format!("{}{registry_block}", first.files["yarn.lock"]),
+            first.files["package.json"].clone(),
+        );
+        let newer_url = url.replace(BERRY_UUID, "22222222-2222-4222-8222-222222222222");
+        for (dep_url, gone) in [(&url, None), (&newer_url, Some(BERRY_UUID))] {
+            let dep = berry_override("left-pad", "1.3.0", dep_url, &checksum);
+            let mut r = RewriteResult::default();
+            rewrite_yarn_berry(&drifted, std::slice::from_ref(&dep), &mut r);
+            assert!(
+                !r.warnings
+                    .iter()
+                    .any(|w| w.code == "redirect_yarn_berry_ambiguous_entry"),
+                "{:?}",
+                r.warnings
+            );
+            assert!(r
+                .confirmed_yarn_berry_uuids
+                .contains(dep.patch_uuid.as_str()));
+            let out = &r.files["yarn.lock"];
+            assert!(out.contains(&format!("\"left-pad@{dep_url}\":")), "{out}");
+            assert!(!out.contains("left-pad@npm:1.3.0"), "{out}");
+            assert_eq!(out.matches("version: 1.3.0").count(), 1, "{out}");
+            if let Some(old) = gone {
+                assert!(!out.contains(old), "{out}");
+            }
+            let manifest: Value = serde_json::from_str(&r.files["package.json"]).unwrap();
+            assert_eq!(
+                manifest["resolutions"],
+                json!({"left-pad@npm:^1.3.0": dep_url, "left-pad@npm:1.3.0": dep_url})
+            );
+            // The folded pin is complete: another run changes nothing.
+            let mut again = RewriteResult::default();
+            rewrite_yarn_berry(
+                &berry_files(out.clone(), r.files["package.json"].clone()),
+                std::slice::from_ref(&dep),
+                &mut again,
+            );
+            assert!(again.warnings.is_empty(), "{:?}", again.warnings);
+            assert!(again.files.is_empty(), "{:?}", again.files);
+        }
+
+        // Two registry entries and no pin of ours stay ambiguous.
+        let two = berry_files(
+            format!("{}{registry_block}", berry_lock("10c0")),
+            berry_manifest(),
+        );
+        let mut r = RewriteResult::default();
+        rewrite_yarn_berry(&two, std::slice::from_ref(&ovr), &mut r);
+        assert!(r.files.is_empty(), "{:?}", r.files);
+        assert!(r
+            .warnings
+            .iter()
+            .any(|w| w.code == "redirect_yarn_berry_ambiguous_entry"));
+    }
+
     /// The URL-keyed lock entry alone is half a pin: with its manifest
     /// `resolutions` routing removed, yarn installs nothing from it, so the
     /// rewriter owns the dep yet never confirms it — a URL in the lock must
 
@@ -886,6 +886,7 @@ async fn restore_berry(
     let dists = fetch_dists_on(&wanted, registry, ctx, result).await;
     let mut changed = false;
     let mut moved: Vec<String> = Vec::new();
+    let mut restored: Vec<usize> = Vec::new();
     for Hit {
         idx,
         uuid,
@@ -1003,11 +1004,13 @@ async fn restore_berry(
             }
         }
         result.handled.insert(uuid);
+        restored.push(idx);
         changed = true;
     }
     if !changed {
         return;
     }
+    merge_same_resolution(&mut blocks, &restored, &mut moved);
     if pkg_changed {
         if let (Some(text), Some(value)) = (pkg_text.as_deref(), pkg.as_mut()) {
             if let Some(obj) = value.as_object_mut() {
@@ -1037,6 +1040,54 @@ async fn restore_berry(
     view.write(rel, doc.render(&moved));
 }
 
+/// Fold each restored berry entry into another entry of `blocks` with the
+/// same `resolution:` (#1082). A descriptor added after the hosted pin (a
+/// workspace member's range, an `npm:` alias) got its own registry entry,
+/// because no selector routed it to the tarball; once the pin is gone,
+/// yarn writes the two as one entry keyed by every descriptor, sorted,
+/// and `--immutable` rejects a lock that keeps them apart (YN0028). The
+/// entry yarn wrote keeps its body; the restored one only adds its keys.
+fn merge_same_resolution(blocks: &mut Vec<String>, restored: &[usize], moved: &mut Vec<String>) {
+    use crate::formats::yarn::blocks::berry_field;
+    use crate::formats::yarn::patterns::split_berry_key_patterns;
+    use crate::formats::yarn::stanzas::{stanza_key, stanza_lines};
+
+    let resolution_of =
+        |block: &str| berry_field(&stanza_lines(block), "resolution").map(str::to_string);
+    let mut dropped: Vec<usize> = Vec::new();
+    for &idx in restored {
+        let Some(resolution) = resolution_of(&blocks[idx]) else {
+            continue;
+        };
+        let Some(sibling) = (0..blocks.len()).find(|&j| {
+            j != idx
+                && !dropped.contains(&j)
+                && stanza_key(&blocks[j]).is_some_and(|k| k != "__metadata")
+                && resolution_of(&blocks[j]).as_deref() == Some(resolution.as_str())
+        }) else {
+            continue;
+        };
+        let mut patterns: Vec<String> = [&blocks[sibling], &blocks[idx]]
+            .iter()
+            .flat_map(|b| split_berry_key_patterns(stanza_key(b).unwrap_or("")))
+            .collect();
+        patterns.sort();
+        patterns.dedup();
+        let old_key = stanza_key(&blocks[idx]).unwrap_or("").to_string();
+        moved.retain(|k| *k != old_key);
+        let key = format!("\"{}\"", patterns.join(", "));
+        let mut lines = stanza_lines(&blocks[sibling]);
+        lines[0] = format!("{key}:");
+        blocks[sibling] = lines.join("\n");
+        moved.push(key);
+        dropped.push(idx);
+    }
+    dropped.sort_unstable_by(|a, b| b.cmp(a));
+    for idx in dropped {
+        blocks.remove(idx);
+    }
+}
+
 /// Retire the leftover hosted `resolutions` selectors of a yarn berry root
 /// `package.json` (#1203): `yarn remove` / `yarn up` deleted the lock entry
 /// a hosted pin keyed by its tarball URL but left its selector, which now