GeezerVison

diff --git a/crates/socket-patch-cli/src/commands/remove.rs b/crates/socket-patch-cli/src/commands/remove.rs
--- a/crates/socket-patch-cli/src/commands/remove.rs
+++ b/crates/socket-patch-cli/src/commands/remove.rs
@@ -13,7 +13,7 @@
 
 use super::get::short_uuid;
 use super::rollback::{all_files_already_original, pin_before_hash_blobs, rollback_patches};
-use super::vendor::{dispatch_revert_one, dispatch_revert_one_opts};
+use super::vendor::dispatch_revert_one_opts;
 use crate::args::{apply_env_toggles, GlobalArgs};
 use socket_patch_core::vendor::RevertOpts;
 use crate::commands::lock_cli::acquire_or_emit;
@@ -1224,7 +1224,15 @@
     let mut env = Envelope::new(Command::Remove);
     env.dry_run = args.common.dry_run;
     for (key, entry) in &detached {
-        let outcome = dispatch_revert_one(entry, &args.common.cwd, args.common.dry_run).await;
+        let outcome = dispatch_revert_one_opts(
+            entry,
+            &args.common.cwd,
+            RevertOpts {
+                dry_run: args.common.dry_run,
+                keep_artifact: args.preserve_state,
+            },
+        )
+        .await;
         for w in &outcome.warnings {
             if !args.common.json && !args.common.silent {
                 eprintln!("Warning ({}): {}", w.code, w.detail);
@@ -1252,9 +1260,31 @@
             );
             return 1;
         }
+        if outcome.kept_artifact {
+            // Drift-keep: the lock changed under us and the backend
+            // left both the wiring and the artifact alone. Per the
+            // RevertOutcome contract the ledger entry stays.
+            if !args.common.json && !args.common.silent {
+                eprintln!(
+                    "Kept vendored state for {key}: lockfile wiring drifted; \
+                     ledger entry kept too"
+                );
+            }
+            env.record(
+                PatchEvent::new(PatchAction::Skipped, key.clone()).with_reason(
+                    "vendor_revert_kept",
+                    "lockfile wiring drifted; vendored state and ledger entry kept",
+                ),
+            );
+            continue;
+        }
         if args.common.dry_run {
             if !args.common.json && !args.common.silent {
-                println!("Would revert vendoring for {key}");
+                if args.preserve_state {
+                    println!("Would unwire vendoring for {key} (artifact preserved)");
+                } else {
+                    println!("Would revert vendoring for {key}");
+                }
             }
             // Verified preview (the dry-run convention); still recorded
             // so `summary.verified` counts the would-be removals.
@@ -1266,6 +1296,22 @@
             );
             continue;
         }
+        if args.preserve_state {
+            // Entry kept byte-identical: its already-reverted wiring
+            // records replay as silent no-ops later (the liveness
+            // contract) and a re-vendor re-wires from the live lock.
+            if !args.common.json && !args.common.silent {
+                println!("Unwired vendoring for {key} (artifact preserved)");
+            }
+            env.record(
+                PatchEvent::new(PatchAction::Skipped, key.clone()).with_reason(
+                    "vendor_state_preserved",
+                    "lockfile unwired; artifact and ledger entry preserved \
+                     (--preserve-state)",
+                ),
+            );
+            continue;
+        }
         state.entries.remove(key);
         if let Err(e) = save_state(&args.common.cwd, &state).await {
             emit_error_envelope(

diff --git a/crates/socket-patch-core/src/patch/redirect/takeover.rs b/crates/socket-patch-core/src/patch/redirect/takeover.rs
--- a/crates/socket-patch-core/src/patch/redirect/takeover.rs
+++ b/crates/socket-patch-core/src/patch/redirect/takeover.rs
@@ -86,17 +86,51 @@
 }
 
 /// Read a project file, distinguishing missing (`Ok(None)`) from unreadable.
+/// Guarded via [`crate::utils::fs::open_regular_file`]: a FIFO at the lock
+/// path would block forever on bare `read_to_string`.
 async fn read_rel(project_root: &Path, rel: &str) -> Result<Option<String>, String> {
-    match tokio::fs::read_to_string(project_root.join(rel)).await {
-        Ok(c) => Ok(Some(c)),
+    use tokio::io::AsyncReadExt;
+    let path = project_root.join(rel);
+    match crate::utils::fs::open_regular_file(&path).await {
+        Ok((mut file, _)) => {
+            let mut content = String::new();
+            file.read_to_string(&mut content)
+                .await
+                .map_err(|e| format!("read {rel}: {e}"))?;
+            Ok(Some(content))
+        }
         Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(None),
+        Err(e) if e.kind() == std::io::ErrorKind::InvalidInput => {
+            Err(format!("read {rel}: not a regular file (FIFO/device/directory)"))
+        }
         Err(e) => Err(format!("read {rel}: {e}")),
     }
 }
 
 async fn write_rel(project_root: &Path, rel: &str, content: &str) -> Result<(), String> {
-    tokio::fs::write(project_root.join(rel), content)
+    use tokio::io::AsyncWriteExt;
+    let path = project_root.join(rel);
+    // Guarded write: open with O_CREAT|O_WRONLY|O_TRUNC, then check the
+    // opened handle is a regular file before writing. A FIFO at the lock
+    // path would block forever on bare `write`.
+    let mut file = tokio::fs::OpenOptions::new()
+        .write(true)
+        .create(true)
+        .truncate(true)
+        .open(&path)
         .await
+        .map_err(|e| format!("write {rel}: {e}"))?;
+    let metadata = file
+        .metadata()
+        .await
+        .map_err(|e| format!("write {rel}: {e}"))?;
+    if !metadata.is_file() {
+        return Err(format!(
+            "write {rel}: not a regular file (FIFO/device/directory)"
+        ));
+    }
+    file.write_all(content.as_bytes())
+        .await
         .map_err(|e| format!("write {rel}: {e}"))
 }