fix(scan,crawler): surface the pre-failure vendor reconcile in JSON; treat empty CARGO_HOME as unset

Two more fixes the sweep's own RED regression tests were pinning:

* scan --vendor --json: reconcile_dropped mutates the on-disk ledger
  BEFORE staging, but a staging failure returned Err without the
  envelope — the JSON consumer saw only the error object and never
  learned entries had been reverted on disk. The step error now carries
  the envelope built so far and the JSON fold attaches it as `vendor`.
  (Human mode prints no per-event lines even on success; unchanged.)

* cargo crawler: CARGO_HOME="" hit PathBuf::from("") and resolved
  registry/src against the CWD, silently crawling nothing. Empty now
  means unset (env_non_empty convention), falling back to ~/.cargo.

Pinned by scan_vendor_staging_error_still_reports_the_reconcile and
empty_cargo_home_falls_back_to_home_dot_cargo.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: mikolalysenko

crates/socket-patch-cli/src/commands/scan/vendor_flow.rs

@@ -61,19 +61,23 @@ async fn preview_vendor_json(cwd: &Path, selected: &[PatchSearchResult]) -> serd
 /// [`download_patch_records`]; no manifest involvement at all).
 ///
 /// `Ok((has_errors, envelope))` on a run that reached the engine;
-/// `Err((code, message))` for the lock/stage/manifest failures the
-/// caller folds into its own output shape (scan's ad-hoc JSON can't use
-/// `acquire_or_emit`, which prints an Envelope).
+/// `Err((code, message, envelope))` for the lock/stage/manifest failures
+/// the caller folds into its own output shape (scan's ad-hoc JSON can't
+/// use `acquire_or_emit`, which prints an Envelope). The error carries
+/// the envelope built so far when the failure happened AFTER
+/// `reconcile_dropped` ran — the reconcile mutates the on-disk ledger,
+/// and its events must survive the error fold or the JSON consumer
+/// never learns about the mutation.
 async fn run_scan_vendor_step(
     common: &GlobalArgs,
     manifest_path: &Path,
     socket_dir: &Path,
     detached_records: Option<&HashMap<String, PatchRecord>>,
-) -> Result<(bool, Envelope), (&'static str, String)> {
+) -> Result<(bool, Envelope), (&'static str, String, Option<Box<Envelope>>)> {
     // The download phase created `.socket/` already in every flow that
     // reaches here, but `acquire` deliberately refuses to mkdir.
     if let Err(e) = tokio::fs::create_dir_all(socket_dir).await {
-        return Err(("socket_dir_unwritable", e.to_string()));
+        return Err(("socket_dir_unwritable", e.to_string(), None));
     }
     let guard = apply_lock::acquire(
         socket_dir,
@@ -83,8 +87,9 @@ async fn run_scan_vendor_step(
         apply_lock::LockError::Held => (
             "lock_held",
             "another socket-patch process is operating in this directory".to_string(),
+            None,
         ),
-        apply_lock::LockError::Io { .. } => ("lock_io", e.to_string()),
+        apply_lock::LockError::Io { .. } => ("lock_io", e.to_string(), None),
     })?;
 
     let mut env = Envelope::new(EnvelopeCommand::Vendor);
@@ -111,7 +116,7 @@ async fn run_scan_vendor_step(
                     drop(guard);
                     return Ok((false, env));
                 }
-                Err(e) => return Err(("invalid_manifest", e.to_string())),
+                Err(e) => return Err(("invalid_manifest", e.to_string(), None)),
             };
             // Same placement as the `vendor` command: dropped entries
             // are reverted even when zero in-scope patches remain.
@@ -123,12 +128,15 @@ async fn run_scan_vendor_step(
         match stage_vendor_sources_in_memory(common, &manifest, socket_dir, &common.cwd).await {
             Ok(MemStageOutcome::Ready(s)) => s,
             Ok(MemStageOutcome::Unavailable) => {
+                // The reconcile above may have already reverted dropped
+                // entries on disk — hand its envelope to the error fold.
                 return Err((
                     "no_local_source",
                     "patch artifacts unavailable (offline or download failure)".to_string(),
-                ))
+                    Some(Box::new(env)),
+                ));
             }
-            Err(e) => return Err(("stage_failed", e)),
+            Err(e) => return Err(("stage_failed", e, Some(Box::new(env)))),
         };
     let sources = staged.as_patch_sources();
     has_errors |=
@@ -280,14 +288,21 @@ async fn run_vendor_json_path(
                 serde_json::to_value(&venv).unwrap_or_else(|_| serde_json::json!({}));
             i32::from(has_errors)
         }
-        Err((code, message)) => {
+        Err((code, message, venv)) => {
             track_patch_vendor_failed(
                 &message,
                 args.common.dry_run,
                 telemetry_token,
                 telemetry_org,
             )
             .await;
+            // A pre-failure reconcile already mutated the ledger on disk;
+            // its envelope (events included) must reach the JSON consumer
+            // even though the run aborts here.
+            if let Some(venv) = venv {
+                result["vendor"] =
+                    serde_json::to_value(&*venv).unwrap_or_else(|_| serde_json::json!({}));
+            }
             result["status"] = serde_json::json!("error");
             result["error"] = serde_json::json!({
                 "code": code,
@@ -378,7 +393,10 @@ async fn run_vendor_interactive_path(
             .await;
             i32::from(has_errors)
         }
-        Err((code, message)) => {
+        // Human mode prints no per-event lines even on success, so the
+        // carried envelope has no human rendering to feed — JSON mode is
+        // where the reconcile events must survive (see the JSON fold above).
+        Err((code, message, _venv)) => {
             track_patch_vendor_failed(
                 &message,
                 args.common.dry_run,
@@ -534,7 +552,11 @@ fn boxed_scan_vendor_step<'a>(
     socket_dir: &'a Path,
     detached_records: Option<&'a HashMap<String, PatchRecord>>,
 ) -> std::pin::Pin<
-    Box<dyn std::future::Future<Output = Result<(bool, Envelope), (&'static str, String)>> + 'a>,
+    Box<
+        dyn std::future::Future<
+                Output = Result<(bool, Envelope), (&'static str, String, Option<Box<Envelope>>)>,
+            > + 'a,
+    >,
 > {
     Box::pin(run_scan_vendor_step(
         common,

crates/socket-patch-core/src/crawlers/cargo_crawler.rs

@@ -395,12 +395,15 @@ impl CargoCrawler {
         Some((name.to_string(), version.to_string()))
     }
 
-    /// Get `CARGO_HOME`, defaulting to `$HOME/.cargo`.
+    /// Get `CARGO_HOME`, defaulting to `$HOME/.cargo`. An empty value means
+    /// unset (the env_non_empty convention) — `PathBuf::from("")` would
+    /// otherwise resolve `registry/src` against the CWD and silently crawl
+    /// nothing.
     fn cargo_home() -> PathBuf {
-        if let Ok(cargo_home) = std::env::var("CARGO_HOME") {
-            return PathBuf::from(cargo_home);
+        match std::env::var("CARGO_HOME") {
+            Ok(v) if !v.trim().is_empty() => PathBuf::from(v),
+            _ => crate::utils::fs::home_dir().join(".cargo"),
         }
-        crate::utils::fs::home_dir().join(".cargo")
     }
 }