Carry opt-in fields through check output

Register manifest and detached vendor metadata for both check JSON envelopes, including already-patched and drift events. Represent detached vendor state in manifest-free JSON without changing unrelated empty applies.

Keep human output deduplicated by UUID and note, and leave direct UUID dry-run rendering to its preview layer. Extend the output matrix with human and JSON assertions for every mode and operation.

Assisted-by: Claude Code:kimi-k3p1-pro

Author: Wenxin-Jiang

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

@@ -422,6 +422,9 @@ async fn run_check(args: &ApplyArgs, manifest_path: &Path) -> i32 {
         Err(e) => return refuse_unreadable_manifest(args, manifest_path, &e),
     };
 
+    let mut opt_ins = opt_in_patches(&manifest);
+    opt_ins.extend(vendor_opt_in_patches(&args.common).await);
+
     // (purl_or_name, reason_code, detail) for each drift.
     let mut drifts: Vec<(String, String, String)> = Vec::new();
     let mut checked: usize = 0;
@@ -604,23 +607,22 @@ async fn run_check(args: &ApplyArgs, manifest_path: &Path) -> i32 {
     }
 
     if !args.common.json && !args.common.silent {
-        if let Some(notes) =
-            crate::ui::opt_in_note_block(manifest.patches.iter().map(|(purl, record)| {
-                crate::ui::OptInEntry {
-                    purl,
-                    uuid: &record.uuid,
-                    requires_opt_in: record.requires_opt_in,
-                    opt_in_note: record.opt_in_note.as_deref(),
-                }
-            }))
-        {
+        if let Some(notes) = crate::ui::opt_in_note_block(opt_ins.iter().map(
+            |(purl, uuid, requires_opt_in, opt_in_note)| crate::ui::OptInEntry {
+                purl,
+                uuid,
+                requires_opt_in: *requires_opt_in,
+                opt_in_note: opt_in_note.as_deref(),
+            },
+        )) {
             println!("\n{notes}");
         }
     }
 
     if drifts.is_empty() {
         if args.common.json {
             let mut env = Envelope::new(Command::Apply);
+            register_opt_ins(&mut env, &opt_ins);
             record_check_skips(&mut env, &in_sync, &not_installed);
             for event in unchecked_events {
                 env.record(event);
@@ -637,6 +639,7 @@ async fn run_check(args: &ApplyArgs, manifest_path: &Path) -> i32 {
     } else {
         if args.common.json {
             let mut env = Envelope::new(Command::Apply);
+            register_opt_ins(&mut env, &opt_ins);
             for (id, code, detail) in &drifts {
                 env.record(
                     PatchEvent::new(PatchAction::Failed, id.clone())
@@ -1305,6 +1308,21 @@ pub async fn run(args: ApplyArgs) -> i32 {
             env.status = Status::NoManifest;
             env.dry_run = args.common.dry_run;
             env.warnings.extend(below.warnings());
+            let vendor_patches = vendor_opt_in_patches(&args.common).await;
+            for (purl, uuid, requires_opt_in, opt_in_note) in &vendor_patches {
+                if requires_opt_in != &Some(true) && opt_in_note.is_none() {
+                    continue;
+                }
+                env.register_opt_in(purl, uuid, *requires_opt_in, opt_in_note.as_deref());
+                env.record(
+                    PatchEvent::new(PatchAction::Skipped, purl.clone())
+                        .with_uuid(uuid.clone())
+                        .with_reason(
+                            "already_vendored",
+                            "vendored patch is recorded in .socket/vendor/state.json",
+                        ),
+                );
+            }
             match &vex_result {
                 Some(ManifestlessVex::Written(summary)) => {
                     env.vex = Some(VexSummary {
@@ -1519,21 +1537,19 @@ fn collect_apply_outcomes(
 }
 
 async fn print_vendor_opt_in_notes(common: &GlobalArgs) {
-    if common.json || common.silent || common.is_global() {
+    if common.json || common.silent {
         return;
     }
-    let Ok(state) = socket_patch_core::vendor::load_state(&common.cwd).await else {
-        return;
-    };
-    let entries = state.entries.values().filter_map(|entry| {
-        let record = entry.record.as_ref()?;
-        Some(crate::ui::OptInEntry {
-            purl: &entry.base_purl,
-            uuid: &record.uuid,
-            requires_opt_in: record.requires_opt_in,
-            opt_in_note: record.opt_in_note.as_deref(),
-        })
-    });
+    let patches = vendor_opt_in_patches(common).await;
+    let entries =
+        patches.iter().map(
+            |(purl, uuid, requires_opt_in, opt_in_note)| crate::ui::OptInEntry {
+                purl,
+                uuid,
+                requires_opt_in: *requires_opt_in,
+                opt_in_note: opt_in_note.as_deref(),
+            },
+        );
     if let Some(notes) = crate::ui::opt_in_note_block(entries) {
         println!("\n{notes}");
     }
@@ -1556,6 +1572,34 @@ fn opt_in_patches(manifest: &PatchManifest) -> OptInPatches {
         .collect()
 }
 
+async fn vendor_opt_in_patches(common: &GlobalArgs) -> OptInPatches {
+    if common.is_global() {
+        return Vec::new();
+    }
+    let Ok(state) = socket_patch_core::vendor::load_state(&common.cwd).await else {
+        return Vec::new();
+    };
+    state
+        .entries
+        .into_iter()
+        .filter_map(|(purl, entry)| {
+            let record = entry.record?;
+            Some((
+                purl,
+                record.uuid,
+                record.requires_opt_in,
+                record.opt_in_note,
+            ))
+        })
+        .collect()
+}
+
+fn register_opt_ins(env: &mut Envelope, patches: &OptInPatches) {
+    for (purl, uuid, requires_opt_in, opt_in_note) in patches {
+        env.register_opt_in(purl, uuid, *requires_opt_in, opt_in_note.as_deref());
+    }
+}
+
 /// The locked half of `apply`: everything from the manifest read on — the
 /// package-manager layout gate, the apply loop, embedded VEX, output and
 /// telemetry — over a `lock` the caller already holds and the caller's
@@ -1612,7 +1656,8 @@ pub(crate) async fn run_locked(
 
     // Packages the project patched itself sit this run out (warned); every
     // other record still applies. The read-only `--check` verifies them all.
-    let opt_ins = opt_in_patches(&manifest);
+    let mut opt_ins = opt_in_patches(&manifest);
+    opt_ins.extend(vendor_opt_in_patches(&args.common).await);
     let mut manifest = manifest;
     let (user_patch_warnings, user_patch_skips) = if args.check {
         Default::default()
@@ -1937,9 +1982,7 @@ pub(crate) async fn run_locked(
             if args.common.json {
                 let mut env = Envelope::new(Command::Apply);
                 env.dry_run = args.common.dry_run;
-                for (purl, uuid, requires_opt_in, opt_in_note) in &opt_ins {
-                    env.register_opt_in(purl, uuid, *requires_opt_in, opt_in_note.as_deref());
-                }
+                register_opt_ins(&mut env, &opt_ins);
                 for skip in &user_patch_skips {
                     env.record(skip.clone());
                 }

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

@@ -1356,7 +1356,7 @@ pub async fn run(args: GetArgs) -> i32 {
                         .await
                     }
                 };
-                if !quiet && mode == super::scan::ScanMode::Agent {
+                if !quiet && !args.common.dry_run && mode == super::scan::ScanMode::Agent {
                     if let Some(notes) =
                         crate::ui::opt_in_note_block([crate::ui::OptInEntry::from_response(&patch)])
                     {

crates/socket-patch-cli/tests/opt_in_output_matrix.rs

@@ -33,6 +33,7 @@ enum Action {
     Real,
     DryRun,
     SaveOnly,
+    Check,
 }
 
 impl CommandKind {
@@ -62,6 +63,7 @@ impl Action {
             Self::Real => "real",
             Self::DryRun => "dry-run",
             Self::SaveOnly => "save-only",
+            Self::Check => "check",
         }
     }
 }
@@ -165,6 +167,7 @@ fn get_args(server: &MockServer, mode: Mode, action: Action) -> Vec<String> {
         Action::Real => {}
         Action::DryRun => args.push("--dry-run".into()),
         Action::SaveOnly => args.push("--save-only".into()),
+        Action::Check => args.push("--check".into()),
     }
     args
 }
@@ -206,6 +209,11 @@ async fn stage_state(
             AFTER_BYTES,
         )
         .unwrap();
+        std::fs::write(
+            root.join("node_modules").join(NAME).join("index.js"),
+            AFTER_BYTES,
+        )
+        .unwrap();
     }
 }
 
@@ -222,10 +230,26 @@ fn opt_in_output_matrix() {
             for action in [Action::Real, Action::DryRun, Action::SaveOnly] {
                 runtime.block_on(run_case(command, mode, action));
             }
+            if matches!(command, CommandKind::Apply) {
+                runtime.block_on(run_case(command, mode, Action::Check));
+            }
         }
     }
 }
 
+fn assert_json_opt_in(stdout: &str, stderr: &str, label: &str) {
+    let doc: serde_json::Value = serde_json::from_str(stdout)
+        .unwrap_or_else(|e| panic!("{label}: JSON {e}; stdout={stdout}\nstderr={stderr}"));
+    let event = doc["events"]
+        .as_array()
+        .unwrap()
+        .iter()
+        .find(|event| event["uuid"] == UUID || event["purl"] == PURL)
+        .unwrap_or_else(|| panic!("{label}: no matching event in {doc}"));
+    assert_eq!(event["details"]["requiresOptIn"], true, "{label}: {event}");
+    assert_eq!(event["details"]["optInNote"], NOTE, "{label}: {event}");
+}
+
 async fn run_case(command: CommandKind, mode: Mode, action: Action) {
     let valid = !matches!(action, Action::SaveOnly)
         || matches!((command, mode), (CommandKind::Get, Mode::Agent));
@@ -252,7 +276,12 @@ async fn run_case(command: CommandKind, mode: Mode, action: Action) {
             args.push("--save-only".into());
         }
     }
+    if matches!(command, CommandKind::Apply) && matches!(action, Action::Check) {
+        args.push("--check".into());
+    }
 
+    let mut json_args = args.clone();
+    json_args.push("--json".into());
     let (code, stdout, stderr) = if matches!(command, CommandKind::Apply | CommandKind::List) {
         stage_state(tmp.path(), &server, mode, command).await;
         server.reset().await;
@@ -273,4 +302,32 @@ async fn run_case(command: CommandKind, mode: Mode, action: Action) {
             "{label} must not fetch patch metadata"
         );
     }
+
+    if matches!(action, Action::Check) && matches!(mode, Mode::Agent) {
+        std::fs::write(
+            tmp.path().join("node_modules").join(NAME).join("index.js"),
+            BEFORE_BYTES,
+        )
+        .unwrap();
+    }
+    let (code, json, stderr) = run_argv(tmp.path(), json_args);
+    if valid {
+        let expected_code = if matches!(action, Action::Check) && matches!(mode, Mode::Agent) {
+            1
+        } else {
+            0
+        };
+        assert_eq!(
+            code, expected_code,
+            "{label} JSON: stdout={json}\nstderr={stderr}"
+        );
+        assert_json_opt_in(&json, &stderr, &label);
+    } else {
+        assert_ne!(code, 0, "{label} JSON: stdout={json}\nstderr={stderr}");
+        assert!(!json.contains(NOTE), "{label}: {json}");
+        assert!(
+            received_paths(&server).await.is_empty(),
+            "{label} JSON must not fetch patch metadata"
+        );
+    }
 }