diff --git a/‎crates/socket-patch-cli/tests/in_process_vendor.rs‎
Lines changed: 82 additions & 0 deletions b/‎crates/socket-patch-cli/tests/in_process_vendor.rs‎
Lines changed: 82 additions & 0 deletions
diff --git a/‎crates/socket-patch-cli/tests/scan_vendor_e2e.rs‎
Lines changed: 91 additions & 0 deletions b/‎crates/socket-patch-cli/tests/scan_vendor_e2e.rs‎
Lines changed: 91 additions & 0 deletions
diff --git a/‎crates/socket-patch-core/src/vendor/bun_binary.rs‎
Lines changed: 4 additions & 0 deletions b/‎crates/socket-patch-core/src/vendor/bun_binary.rs‎
Lines changed: 4 additions & 0 deletions
@@ -543,6 +543,88 @@ async fn rollback_after_dependency_removed_cleans_up_and_converges() {
     assert!(events(&env).is_empty(), "nothing left to revert: {env:#}");
 }
 
+/// What `npm install left-pad@1.3.1` leaves behind after vendoring 1.3.0:
+/// the same lock key, now resolving the new version from the registry.
+fn upgrade_vendored_left_pad(fx: &NpmFixture) -> Vec<u8> {
+    let mut lock = fx.lock_value();
+    lock["packages"]["node_modules/left-pad"] = json!({
+        "version": "1.3.1",
+        "resolved": "https://registry.npmjs.org/left-pad/-/left-pad-1.3.1.tgz",
+        "integrity": "sha512-upgraded=="
+    });
+    let mut upgraded = serde_json::to_vec_pretty(&lock).unwrap();
+    upgraded.push(b'\n');
+    std::fs::write(fx.lock_path(), &upgraded).unwrap();
+    upgraded
+}
+
+/// #1155: moving a vendored package off its patched version (`npm install
+/// left-pad@1.3.1`, a Dependabot bump) takes the vendored version out of
+/// the lock graph just like `npm uninstall`. `rollback` used to call that
+/// drift, keep the artifact and ledger entry and exit 1 on every run, so
+/// `vendor --check` stayed red. Now the first rollback cleans up, leaves
+/// the user's upgraded lock alone, and later runs are clean no-ops.
+#[tokio::test]
+async fn rollback_after_version_upgrade_cleans_up_and_converges() {
+    let fx = npm_fixture();
+    assert_eq!(vendor_run(vendor_args(fx.root())).await, 0);
+    let upgraded = upgrade_vendored_left_pad(&fx);
+
+    let cwd = fx.root().to_str().unwrap();
+    let (code, stdout, stderr) = run_cli(
+        fx.root(),
+        &["rollback", "--json", "--yes", "--offline", "--cwd", cwd],
+        &[],
+    );
+    assert_eq!(code, 0, "rollback must succeed:\n{stdout}\n{stderr}");
+    assert!(
+        !stdout.contains("vendor_artifact_kept") && !stdout.contains("drifted"),
+        "nothing is kept as drift:\n{stdout}"
+    );
+    assert!(
+        !fx.vendor_dir().exists(),
+        "the unreferenced artifact and ledger are cleaned up:\n{stdout}"
+    );
+    assert_eq!(fx.lock_bytes(), upgraded, "the user's lock is untouched");
+
+    let (code, env) = vendor_cli(fx.root(), &["--revert"]);
+    assert_eq!(code, 0, "{env:#}");
+    assert!(events(&env).is_empty(), "nothing left to revert: {env:#}");
+    let (code, env) = vendor_cli(fx.root(), &["--check"]);
+    assert_eq!(code, 0, "vendor --check is green again: {env:#}");
+}
+
+/// #1155, `remove` leg: it used to end on "drift-kept …; re-run `scan
+/// --mode vendored` to normalize, then remove again", a remedy that
+/// changes nothing. Now it reverts the entry and exits 0.
+#[tokio::test]
+async fn remove_after_version_upgrade_reverts_vendoring() {
+    let fx = npm_fixture();
+    assert_eq!(vendor_run(vendor_args(fx.root())).await, 0);
+    let upgraded = upgrade_vendored_left_pad(&fx);
+
+    let (code, stdout, stderr) = run_cli(
+        fx.root(),
+        &[
+            "remove",
+            PURL,
+            "--json",
+            "--offline",
+            "--yes",
+            "--cwd",
+            fx.root().to_str().unwrap(),
+        ],
+        &[],
+    );
+    assert_eq!(code, 0, "remove must succeed:\n{stdout}\n{stderr}");
+    let env: Value = serde_json::from_str(&stdout).unwrap();
+    let reverted = find_event(&env, "removed", Some("vendor_reverted"));
+    assert_eq!(reverted["purl"], PURL);
+    assert!(!stdout.contains("drift-kept"), "{env:#}");
+    assert!(!fx.vendor_dir().exists(), "vendor tree fully removed");
+    assert_eq!(fx.lock_bytes(), upgraded, "the user's lock is untouched");
+}
+
 // ─────────────────────────────────────────────────────────────────────
 // 5. revert works without a manifest
 // ─────────────────────────────────────────────────────────────────────
 
@@ -1161,6 +1161,97 @@ async fn scan_prune_reverts_unused_vendored_entry() {
     );
 }
 
+/// #1155: `npm install left-pad@1.3.1` after vendoring 1.3.0 keeps the
+/// `node_modules/left-pad` key but locks the new version from the
+/// registry. The vendored version left the lock graph just as after
+/// `npm uninstall`, so `scan --prune` must revert the entry in one run.
+/// It used to call the moved entry drift and keep it forever, so the
+/// prune remedy `vendor --check` names never converged.
+#[tokio::test]
+async fn scan_prune_reverts_vendored_entry_after_version_upgrade() {
+    let mock = MockServer::start().await;
+    mount_patch_api(&mock, UUID).await;
+    let tmp = tempfile::tempdir().unwrap();
+    write_fixture(tmp.path());
+
+    let (code, stdout, stderr) = run_scan_vendor(tmp.path(), &mock.uri(), &[]);
+    assert_eq!(code, 0, "stdout={stdout}; stderr={stderr}");
+    assert!(tmp
+        .path()
+        .join(format!(".socket/vendor/npm/{UUID}"))
+        .exists());
+
+    // What `npm install left-pad@1.3.1` leaves behind.
+    let lock = serde_json::json!({
+        "name": "scan-vendor-test",
+        "version": "0.0.0",
+        "lockfileVersion": 3,
+        "requires": true,
+        "packages": {
+            "": {
+                "name": "scan-vendor-test",
+                "version": "0.0.0",
+                "dependencies": { "left-pad": "^1.3.1" }
+            },
+            "node_modules/left-pad": {
+                "version": "1.3.1",
+                "resolved": "https://registry.npmjs.org/left-pad/-/left-pad-1.3.1.tgz",
+                "integrity": "sha512-upgraded==",
+                "license": "WTFPL"
+            }
+        }
+    });
+    let mut lock_bytes = serde_json::to_vec_pretty(&lock).unwrap();
+    lock_bytes.push(b'\n');
+    std::fs::write(tmp.path().join("package-lock.json"), &lock_bytes).unwrap();
+    std::fs::write(
+        tmp.path().join("node_modules/left-pad/package.json"),
+        br#"{"name":"left-pad","version":"1.3.1"}"#,
+    )
+    .unwrap();
+
+    let out = Command::new(binary())
+        .args([
+            "scan",
+            "--json",
+            "--prune",
+            "--yes",
+            "--api-url",
+            &mock.uri(),
+            "--api-token",
+            "fake-token",
+            "--org",
+            ORG_SLUG,
+        ])
+        .current_dir(tmp.path())
+        .output()
+        .expect("run");
+    let stdout = String::from_utf8_lossy(&out.stdout).into_owned();
+    assert_eq!(out.status.code(), Some(0), "stdout={stdout}");
+    let v: serde_json::Value = serde_json::from_str(stdout.trim()).expect("valid JSON");
+    assert_eq!(
+        v["gc"]["revertedVendoredEntries"],
+        serde_json::json!([PURL]),
+        "gc must revert the upgraded-away entry: {v}"
+    );
+    assert_eq!(
+        v["gc"]["keptVendoredEntries"],
+        serde_json::json!([]),
+        "nothing resolves through the artifact, so nothing is kept: {v}"
+    );
+    assert!(
+        !tmp.path()
+            .join(format!(".socket/vendor/npm/{UUID}"))
+            .exists(),
+        "artifact dir removed"
+    );
+    assert_eq!(
+        std::fs::read(tmp.path().join("package-lock.json")).unwrap(),
+        lock_bytes,
+        "the user's upgraded lock is left exactly as they wrote it"
+    );
+}
+
 /// #541, npm package-lock flavor: after `npm uninstall left-pad` re-locks
 /// the project without the vendored dependency, a vendored rescan skips
 /// the stale ledger entry with a `vendor_ledger_entry_unwired` warning
 
@@ -644,10 +644,14 @@ pub(crate) async fn revert(entry: &VendorEntry, root: &Path, opts: RevertOpts) -
             if let RevertLock::Migrated(lines) = &mut lock {
                 if rec.file == TEXT_LOCK && rec.kind == super::bun_lock::KIND_LOCK_PACKAGE {
                     let mut dirty = false;
+                    // `false`: bun.lockb migrations stay outside the #1155
+                    // upgrade path, so a moved default-registry tuple keeps
+                    // its drift verdict here.
                     super::bun_lock::revert_one_record(
                         lines,
                         rec,
                         &entry.uuid,
+                        false,
                         &mut dirty,
                         &mut outcome.warnings,
                     );