Narrow the vendor member refusal

Review follow-ups for the workspace-member refusal:

- Only refuse in an npm project (a directory with package.json), so a
  Python or other service under a pnpm workspace keeps its exit 0.
- vendor --check now asks after reading the manifest, so a manifest
  it cannot read reports that error instead of the member refusal.
- vendor --revert is not refused when the member has its own manifest.
- Name the pnpm root by its canonical path, like the other roots.
- The message no longer claims a member has no lock, since one with a
  stray lock its manager ignores is refused too.

Refs #1921

Assisted-by: Claude Code:claude-opus-5-5

Author: claude

crates/socket-patch-cli/src/commands/vendor.rs

@@ -1152,7 +1152,7 @@ pub async fn run(args: VendorArgs) -> i32 {
 
     // A workspace member's ledger lives at the root: reverting the
     // member's empty one would report success and unwire nothing (#1921).
-    if args.revert {
+    if args.revert && matches!(manifest_exists(&manifest_path).await, Ok(false)) {
         if let Some(message) = member_refusal(&args.common.cwd, "vendor --revert").await {
             return emit_eject_refusal(&args.common, MEMBER_REFUSAL_CODE, &message);
         }
@@ -1290,20 +1290,20 @@ async fn run_check(args: &VendorArgs) -> i32 {
     if state.entries.is_empty() && jvm_orphan.is_some() {
         return emit_eject_refusal(&args.common, "vendor_ledger_missing", JVM_ORPHAN_DETAIL);
     }
-    // A workspace member verifies nothing of its own: the root's ledger
-    // and artifacts are the ones the install uses, so a pass here would
-    // hide a tampered root (#1921).
-    if state.entries.is_empty() && jvm_orphan.is_none() {
-        let manifest_path = args.common.resolved_manifest_path();
-        if !matches!(manifest_exists(&manifest_path).await, Ok(true)) {
-            if let Some(message) = member_refusal(root, "vendor --check").await {
-                return emit_eject_refusal(&args.common, MEMBER_REFUSAL_CODE, &message);
-            }
-        }
-    }
     let manifest_path = args.common.resolved_manifest_path();
     let manifest = match read_manifest(&manifest_path).await {
-        Ok(m) => m.unwrap_or_default(),
+        Ok(Some(m)) => m,
+        // A workspace member verifies nothing of its own: the root's
+        // ledger and artifacts are the ones the install uses, so a pass
+        // here would hide a tampered root (#1921).
+        Ok(None) => {
+            if state.entries.is_empty() && jvm_orphan.is_none() {
+                if let Some(message) = member_refusal(root, "vendor --check").await {
+                    return emit_eject_refusal(&args.common, MEMBER_REFUSAL_CODE, &message);
+                }
+            }
+            Default::default()
+        }
         Err(e) => {
             let err = crate::json_envelope::manifest_load_error(&manifest_path, &e);
             return emit_eject_refusal(&args.common, &err.code, &err.message);
@@ -1498,8 +1498,6 @@ fn artifacts_gitignore_checked(mut ecosystems: impl Iterator<Item = Ecosystem>)
     })
 }
 
-/// A refused eject: the JSON error envelope (`status: error`) or an
-/// `Error:` line (printed even under `--silent`). Exit 1; nothing touched.
 /// The refusal code of a vendor run from a workspace member: the same one
 /// vendored `scan` / `get` use for a member with no lock of its own.
 const MEMBER_REFUSAL_CODE: &str = "vendor_lockfile_missing";
@@ -1509,8 +1507,13 @@ const MEMBER_REFUSAL_CODE: &str = "vendor_lockfile_missing";
 /// Callers ask only when `dir` has no hosted pins and no manifest; this
 /// also requires an empty (or absent) vendor ledger, so the run would
 /// otherwise exit 0 having looked at nothing (#1921). An unreadable
-/// ledger is left to the caller's own refusal.
+/// ledger is left to the caller's own refusal. Only an npm project (a
+/// directory holding `package.json`) is a member: another ecosystem's
+/// project nested under a pnpm workspace is its own project.
 async fn member_refusal(dir: &Path, form: &str) -> Option<String> {
+    if !dir.join("package.json").is_file() {
+        return None;
+    }
     if !load_state(dir).await.ok()?.entries.is_empty() {
         return None;
     }
@@ -1521,16 +1524,18 @@ async fn member_refusal(dir: &Path, form: &str) -> Option<String> {
 
 fn member_refusal_message(dir: &Path, root: &Path, form: &str) -> String {
     format!(
-        "{} is a workspace member with no lockfile, manifest or vendor ledger of its \
-         own: the workspace root {} installs it and holds its patches, which `{form}` \
-         run here cannot see; run socket-patch from {} (the workspace root); nothing \
-         was written",
+        "{} is a workspace member with no manifest or vendor ledger of its own: \
+         the workspace root {} installs it from its lock and holds its patches, which \
+         `{form}` run here cannot see; run socket-patch from {} (the workspace root); \
+         nothing was written",
         dir.display(),
         root.display(),
         root.display()
     )
 }
 
+/// A refused eject: the JSON error envelope (`status: error`) or an
+/// `Error:` line (printed even under `--silent`). Exit 1; nothing touched.
 fn emit_eject_refusal(common: &GlobalArgs, code: &str, message: &str) -> i32 {
     if common.json {
         let mut env = Envelope::new(Command::Vendor);

crates/socket-patch-cli/tests/vendor/vendor_failure_paths.rs

@@ -1426,3 +1426,43 @@ fn vendor_outside_a_workspace_keeps_the_no_manifest_exit() {
     let (code, env) = vendor_cli(fx.root(), &["--check"]);
     assert_eq!(code, 0, "{env:#}");
 }
+
+/// A non-npm project nested in a pnpm workspace (a Python service beside
+/// the JS packages) is its own project, not a member: its `vendor` forms
+/// keep their exit 0.
+#[test]
+fn vendor_in_a_non_npm_dir_under_a_pnpm_workspace_is_not_refused() {
+    let fx = npm_fixture_with_purls(&[]);
+    std::fs::remove_file(fx.manifest_path()).unwrap();
+    std::fs::write(
+        fx.root().join("pnpm-workspace.yaml"),
+        "packages:\n  - 'packages/*'\n",
+    )
+    .unwrap();
+    std::fs::write(fx.root().join("pnpm-lock.yaml"), "lockfileVersion: '9.0'\n").unwrap();
+    let service = fx.root().join("services/api");
+    std::fs::create_dir_all(&service).unwrap();
+    std::fs::write(
+        service.join("pyproject.toml"),
+        "[project]\nname = \"api\"\nversion = \"0.1.0\"\n",
+    )
+    .unwrap();
+
+    for extra in [&[][..], &["--check"][..], &["--revert"][..]] {
+        let (code, env) = vendor_cli(&service, extra);
+        assert_eq!(code, 0, "{extra:?}: {env:#}");
+    }
+}
+
+/// `--revert` in a member that keeps its own manifest (apply mode) is the
+/// documented clean no-op, not the member refusal.
+#[test]
+fn vendor_revert_in_a_member_with_its_own_manifest_is_not_refused() {
+    let fx = npm_fixture_with_purls(&[]);
+    let member = make_workspace_member(&fx);
+    std::fs::create_dir_all(member.join(".socket")).unwrap();
+    std::fs::write(member.join(".socket/manifest.json"), b"{\"patches\":{}}\n").unwrap();
+
+    let (code, env) = vendor_cli(&member, &["--revert"]);
+    assert_eq!(code, 0, "{env:#}");
+}

crates/socket-patch-core/src/hosted/governing_root.rs

@@ -136,19 +136,21 @@ pub async fn npm_family_governing_root(root: &Path) -> Option<(PathBuf, Refusal)
     };
     if let Some(lock) = pnpm_lock_elsewhere(root).await {
         let dir = lock.parent().unwrap_or(&lock);
+        // Canonical, like the other branches' roots: a relative
+        // `lockfile-dir` (`../..`) would otherwise name a `..` path.
+        let pnpm_dir = tokio::fs::canonicalize(dir)
+            .await
+            .unwrap_or_else(|_| dir.to_path_buf());
         // A `package.json` workspace root nested inside the pnpm lock's
         // directory is nearer the member and owns its lock (Bugbot on
         // #901); otherwise pnpm's workspace or `lockfile-dir` governs.
         if let Some((ws_root, refusal)) = workspace {
-            let pnpm_dir = tokio::fs::canonicalize(dir)
-                .await
-                .unwrap_or_else(|_| dir.to_path_buf());
             if ws_root != pnpm_dir && ws_root.starts_with(&pnpm_dir) {
                 return Some((ws_root, refusal));
             }
         }
         return Some((
-            dir.to_path_buf(),
+            pnpm_dir,
             Refusal {
                 code: PNPM_LOCKFILE_ELSEWHERE.to_string(),
                 message: format!(