@@ -114,6 +114,31 @@ pub(crate) fn classic_key_real_name(patterns: &[String]) -> Option<&str> {
     names.all(|n| n == Some(first)).then_some(first)
 }
 
+/// The descriptors every berry `patch:` protocol wraps in `text` (a lock or
+/// a `package.json`), percent-decoded once: `patch:left-pad@http%3A//h/x.tgz
+/// #~/.yarn/patches/x.patch` wraps `left-pad@http://h/x.tgz`. The patch
+/// path after `#` and any `::version=…` binding are dropped.
+pub(crate) fn patch_wrapped_descriptors(text: &str) -> Vec<String> {
+    text.match_indices("patch:")
+        // The protocol opens a range (`name@patch:`) or a quoted value,
+        // never the middle of a word: `x.patch::version=…` is no wrapper.
+        .filter(|&(at, _)| {
+            text[..at]
+                .chars()
+                .next_back()
+                .is_none_or(|c| matches!(c, '@' | '"' | '\'') || c.is_whitespace())
+        })
+        .map(|(at, tag)| {
+            let rest = &text[at + tag.len()..];
+            let end = rest
+                .find(|c: char| matches!(c, '#' | '"' | '\'' | ',') || c.is_whitespace())
+                .unwrap_or(rest.len());
+            crate::utils::purl::percent_decode_purl_component(&rest[..end]).into_owned()
+        })
+        .filter(|inner| !inner.is_empty())
+        .collect()
+}
+
 /// A classic `resolved` value split at its first `#`: the url before it,
 /// and the fragment as a lowercase sha1 when it is 40 hex digits (either
 /// case) — the legacy tarball verifier yarn v1 enforces when no
@@ -195,6 +220,22 @@ pub(crate) fn berry_npm_alias_target(range: &str) -> Option<&str> {
 mod tests {
     use super::*;
 
+    /// #962: the descriptor a `patch:` wraps, as `yarn patch-commit`
+    /// spells it in a lock key, a `resolution:` and a `package.json` value.
+    #[test]
+    fn patch_wrapped_descriptors_decode_what_yarn_patch_wraps() {
+        let lock = "\"left-pad@patch:left-pad@http%3A//h%3A1/x.tgz#~/.yarn/patches/a.patch\":\n  \
+                    resolution: \"left-pad@patch:left-pad@npm%3A1.3.0#~/.yarn/patches/a.patch\
+                    ::version=1.3.0&hash=0d6d28\"\n";
+        assert_eq!(
+            patch_wrapped_descriptors(lock),
+            vec!["left-pad@http://h:1/x.tgz", "left-pad@npm:1.3.0"]
+        );
+        let pkg = r#"{ "resolutions": { "a@npm:1": "patch:a@file%3A./v/a.tgz#./p.patch" } }"#;
+        assert_eq!(patch_wrapped_descriptors(pkg), vec!["a@file:./v/a.tgz"]);
+        assert!(patch_wrapped_descriptors("\"left-pad@npm:1.3.0\":\n").is_empty());
+    }
+
     /// #1271: the classic grammar keeps an empty range (`left-pad@` from
     /// `"left-pad": ""`); the strict berry grammar still rejects it.
     #[test]
 
@@ -1063,23 +1063,15 @@ async fn restore_berry(
 }
 
 /// The hosted patch uuids a yarn `patch:` descriptor in `text` (a berry
-/// lock or a root `package.json`) wraps. `yarn patch-commit` escapes the
-/// inner descriptor (`patch:<name>@http%3A//host/…#<patch path>`); a lock
-/// pinned before 5.0 has the wrapped `npm:…::__archiveUrl=` binding instead.
+/// lock or a root `package.json`) wraps: a tarball-URL pin, or the
+/// `npm:…::__archiveUrl=` binding of a lock pinned before 5.0.
 fn yarn_patch_wrapped_uuids(text: &str, ctx: &Ctx<'_>) -> Vec<String> {
-    use crate::formats::yarn::patterns::split_pattern;
-    use crate::utils::purl::percent_decode_purl_component;
-
-    text.match_indices("patch:")
-        .filter_map(|(at, tag)| {
-            let rest = &text[at + tag.len()..];
-            let end = rest
-                .find(|c: char| {
-                    matches!(c, '#' | '"' | '\'' | ',' | '\n' | '\r') || c.is_whitespace()
-                })
-                .unwrap_or(rest.len());
-            let inner = percent_decode_purl_component(&rest[..end]).into_owned();
-            let (_, reference) = split_pattern(&inner)?;
+    use crate::formats::yarn::patterns::{patch_wrapped_descriptors, split_pattern};
+
+    patch_wrapped_descriptors(text)
+        .iter()
+        .filter_map(|inner| {
+            let (_, reference) = split_pattern(inner)?;
             let url = match reference.split_once("::__archiveUrl=") {
                 Some((_, binding)) => binding.split('&').next().unwrap_or(binding),
                 None => reference,
 
@@ -841,6 +841,28 @@ pub async fn revert_yarn_berry_opts(
             }
         }
     }
+    // A user `yarn patch` over the vendored tarball (#962): restoring the
+    // recorded entry under its `patch:` wrapper leaves a lock every
+    // `yarn install --immutable` rejects, so refuse before either file is
+    // written (and before the dry-run return, so a preview agrees).
+    if let Some(wired) = user_patch_wrapping(project_root, &entry.uuid).await {
+        let detail = format!(
+            "refusing to revert {uuid_dir_rel}: a `patch:` entry from `yarn patch` in {wired} \
+             still wraps the vendored tarball, and restoring the registry entry under it would \
+             leave a lock `yarn install --immutable` rejects — remove the `patch:` resolution \
+             from {PACKAGE_JSON}, run `yarn install`, re-run `vendor --revert`, then re-run \
+             `yarn patch` on the registry version"
+        );
+        return RevertOutcome {
+            success: false,
+            warnings: vec![VendorWarning::new(
+                "vendor_lock_still_wired_revert_blocked",
+                detail.clone(),
+            )],
+            error: Some(detail),
+            kept_artifact: false,
+        };
+    }
     if dry_run {
         return RevertOutcome::ok();
     }
@@ -1102,6 +1124,26 @@ pub async fn revert_yarn_berry_opts(
 
 // ───────────────────────────── revert internals ─────────────────────────────
 
+/// The first wired file (yarn.lock, then package.json) in which a user
+/// `patch:` descriptor wraps the vendored artifact of `uuid` (#962). An
+/// unreadable or missing file wraps nothing here: the wired revert's own
+/// reads report it.
+async fn user_patch_wrapping(project_root: &Path, uuid: &str) -> Option<&'static str> {
+    let needle = uuid.to_ascii_lowercase();
+    for wired in [YARN_LOCK, PACKAGE_JSON] {
+        let Ok(text) = read_regular_to_string(&project_root.join(wired)).await else {
+            continue;
+        };
+        if crate::formats::yarn::patterns::patch_wrapped_descriptors(&text)
+            .iter()
+            .any(|inner| inner.to_ascii_lowercase().contains(&needle))
+        {
+            return Some(wired);
+        }
+    }
+    None
+}
+
 /// Put back an entry vendoring pruned (see [`KIND_LOCK_ENTRY_PRUNED`]):
 /// the rewritten shared entry returns to its original lines, a removed one
 /// is inserted where yarn sorts it. Already restored is silent; anything
@@ -3944,6 +3986,70 @@ __metadata:
         );
     }
 
+    /// #962: the user ran `yarn patch` / `yarn patch-commit -s` over the
+    /// vendored package, so a `patch:` lock entry and `resolutions` value
+    /// wrap the vendored tarball. Restoring the recorded entry would leave
+    /// that wrapper naming a descriptor no entry resolves: every
+    /// `yarn install --immutable` rejects the lock (YN0028). The revert must
+    /// refuse BEFORE writing either file, on a dry run too.
+    #[tokio::test]
+    async fn revert_refuses_before_writing_when_a_user_yarn_patch_wraps_the_artifact() {
+        let fx = fixture().await;
+        let (_, entry, _) = expect_done(fx.vendor(false).await);
+        let entry = entry.unwrap();
+
+        let text = tokio::fs::read_to_string(fx.lock_path()).await.unwrap();
+        let resolution = text
+            .lines()
+            .find_map(|l| l.strip_prefix("  resolution: \"left-pad@"))
+            .and_then(|r| r.strip_suffix('"'))
+            .expect("the vendored lock must carry our resolution line")
+            .to_string();
+        let wrapped = format!(
+            "patch:left-pad@{}#~/.yarn/patches/left-pad-file-0d6d28.patch",
+            resolution.replace(':', "%3A")
+        );
+        let lock = format!(
+            "{text}\n\"left-pad@{wrapped}\":\n  version: 1.3.0\n  \
+             resolution: \"left-pad@{wrapped}::version=1.3.0&hash=0d6d28\"\n  \
+             languageName: node\n  linkType: hard\n"
+        );
+        tokio::fs::write(fx.lock_path(), &lock).await.unwrap();
+        let pkg_text = tokio::fs::read_to_string(fx.pkg_path()).await.unwrap();
+        let mut pkg: Value = serde_json::from_str(&pkg_text).unwrap();
+        pkg["resolutions"][format!("left-pad@{resolution}")] = Value::String(wrapped);
+        let pkg_text = serde_json::to_string_pretty(&pkg).unwrap() + "\n";
+        tokio::fs::write(fx.pkg_path(), &pkg_text).await.unwrap();
+
+        for dry_run in [true, false] {
+            let outcome = revert_yarn_berry(&entry, fx.root(), dry_run).await;
+            assert!(
+                !outcome.success,
+                "dry_run={dry_run}: must refuse under a user `yarn patch`: {:?}",
+                outcome.warnings
+            );
+            assert!(
+                outcome.warnings.iter().any(|w| {
+                    w.code == "vendor_lock_still_wired_revert_blocked"
+                        && w.detail.contains("yarn patch")
+                }),
+                "dry_run={dry_run}: {:?}",
+                outcome.warnings
+            );
+            assert_eq!(
+                tokio::fs::read_to_string(fx.lock_path()).await.unwrap(),
+                lock,
+                "dry_run={dry_run}: yarn.lock untouched"
+            );
+            assert_eq!(
+                tokio::fs::read_to_string(fx.pkg_path()).await.unwrap(),
+                pkg_text,
+                "dry_run={dry_run}: package.json untouched"
+            );
+            assert!(fx.tgz_path().exists(), "the artifact must survive");
+        }
+    }
+
     /// The user re-keys our resolutions entry (`"left-pad"` →
     /// `"left-pad@npm:1.3.0"`) without changing its `file:` value. The
     /// recorded key then reads as already-converged (Added record, key