#[test]
+    fn maps_rehearsal_smoke_install() {
+        let mut opts = sample_runtime_options();
+        opts.rehearsal_smoke_install = Some("shipper".to_string());
+
+        let converted = into_runtime_options(opts);
+
+        assert_eq!(
+            converted.rehearsal_smoke_install.as_deref(),
+            Some("shipper")
+        );
+    }
+
+    #[test]
     fn maps_simple_discriminants() {

-    /// `None` means no smoke install (opt-in). The named crate must
-    /// exist in the plan AND have a `[[bin]]` target.
+    /// `None` means no smoke install (opt-in). If the named crate is not
+    /// in the plan, rehearsal warns and skips the smoke check; if it is in
+    /// the plan, it must have an installable binary target or the smoke
+    /// check fails.

+    #[test]
+    fn event_type_rehearsal_smoke_check_variants_roundtrip() {
+        let events = vec![
+            EventType::RehearsalSmokeCheckStarted {
+                name: "my-cli".to_string(),
+                version: "1.0.0".to_string(),
+                registry: "rehearsal".to_string(),
+            },
+            EventType::RehearsalSmokeCheckSucceeded {
+                name: "my-cli".to_string(),
+                version: "1.0.0".to_string(),
+                duration_ms: 1234,
+            },
+            EventType::RehearsalSmokeCheckFailed {
+                name: "my-cli".to_string(),
+                version: "1.0.0".to_string(),
+                message: "install failed".to_string(),
+            },
+        ];
+
+        for event in events {
+            let json = serde_json::to_string(&event).unwrap();
+            let parsed: EventType = serde_json::from_str(&json).unwrap();
+            assert_eq!(serde_json::to_string(&parsed).unwrap(), json);
+        }
+    }

-    #[arg(long = "smoke-install", global = true, value_name = "CRATE")]
+    #[arg(
+        long = "smoke-install",
+        global = true,
+        value_name = "CRATE",
+        value_parser = parse_non_empty_crate_name
+    )]
     rehearsal_smoke_install: Option<String>,

     let mut packages_published: usize = 0;
     let mut first_failure: Option<String> = None;
+    let mut smoke_note: Option<String> = None;
@@
-                    first_failure = Some(format!(
+                    let failure_summary = format!(
                         "smoke-install of {smoke_name}@{} failed: cargo exit {}",
                         smoke_pkg.version, out.exit_code
-                    ));
+                    );
+                    smoke_note = Some(failure_summary.clone());
+                    first_failure = Some(failure_summary);
                 }
@@
-                reporter.warn(&format!(
+                let msg = format!(
                     "smoke-install target '{smoke_name}' is not in the rehearsal plan; skipping. \
                      Available crates: {}",
                     ws.plan
                         .packages
                         .iter()
                         .map(|p| p.name.as_str())
                         .collect::<Vec<_>>()
                         .join(", ")
-                ));
+                );
+                reporter.warn(&msg);
+                smoke_note = Some(msg);
             }
         }
     }
 
     let passed = first_failure.is_none();
+    let publish_failed = !passed && packages_published < ws.plan.packages.len();
     let summary = if passed {
-        format!("rehearsed {packages_published} packages against '{rehearsal_name}' successfully")
-    } else {
+        let base =
+            format!("rehearsed {packages_published} packages against '{rehearsal_name}' successfully");
+        match smoke_note.as_deref() {
+            Some(note) => format!("{base}; {note}"),
+            None => base,
+        }
+    } else if publish_failed {
         format!(
             "rehearsal stopped at {}/{}: {}",
             packages_published + 1,
             ws.plan.packages.len(),
             first_failure.as_deref().unwrap_or("")
         )
+    } else {
+        format!(
+            "rehearsed {packages_published} packages against '{rehearsal_name}', but {}",
+            first_failure.as_deref().unwrap_or("smoke-install failed")
+        )
     };
@@
-    let packages_attempted = packages_published + if passed { 0 } else { 1 };
+    let packages_attempted = if publish_failed {
+        packages_published + 1
+    } else {
+        packages_published
+    };

         let bin = td.path().join("bin");
         write_fake_tools(&bin);
-        let env_vars = fake_program_env_vars(&bin);
+        let args_log = td.path().join("cargo_args.txt");
+        let mut env_vars = fake_program_env_vars(&bin);
+        env_vars.push((
+            "SHIPPER_CARGO_ARGS_LOG",
+            Some(args_log.to_str().expect("utf8").to_string()),
+        ));
         temp_env::with_vars(env_vars, || {
@@
             assert!(
                 types.contains(&"rehearsal_smoke_check_succeeded".to_string()),
                 "types: {types:?}"
             );
+
+            let cargo_log = fs::read_to_string(&args_log).expect("read cargo args log");
+            let install_line = cargo_log
+                .lines()
+                .find(|line| line.split_whitespace().next() == Some("install"))
+                .expect("expected cargo install invocation");
+            assert!(install_line.contains("--registry rehearsal"), "{install_line}");
+            assert!(install_line.contains("demo"), "{install_line}");
+            assert!(install_line.contains("--version 0.1.0"), "{install_line}");
+            assert!(install_line.contains("--locked"), "{install_line}");
             rehearsal_server.join();
         });