running-process 4.6.2__tar.gz → 4.6.4__tar.gz

{running_process-4.6.2 → running_process-4.6.4}/Cargo.lock

@@ -1351,7 +1351,7 @@ dependencies = [
 
 [[package]]
 name = "running-process"
-version = "4.6.2"
+version = "4.6.4"
 dependencies = [
  "anyhow",
  "blake3",
@@ -1390,7 +1390,7 @@ dependencies = [
 
 [[package]]
 name = "running-process-observer"
-version = "4.6.2"
+version = "4.6.4"
 dependencies = [
  "blake3",
  "dirs",
@@ -1401,21 +1401,21 @@ dependencies = [
 
 [[package]]
 name = "running-process-observer-interposer-linux"
-version = "4.6.2"
+version = "4.6.4"
 dependencies = [
  "libc",
 ]
 
 [[package]]
 name = "running-process-observer-interposer-macos"
-version = "4.6.2"
+version = "4.6.4"
 dependencies = [
  "libc",
 ]
 
 [[package]]
 name = "running-process-observer-interposer-windows"
-version = "4.6.2"
+version = "4.6.4"
 dependencies = [
  "retour",
  "windows-sys 0.59.0",
@@ -1423,7 +1423,7 @@ dependencies = [
 
 [[package]]
 name = "running-process-py"
-version = "4.6.2"
+version = "4.6.4"
 dependencies = [
  "interprocess",
  "libc",
@@ -1437,7 +1437,7 @@ dependencies = [
 
 [[package]]
 name = "running-process-win-gnu-bridge"
-version = "4.6.2"
+version = "4.6.4"
 dependencies = [
  "windows-sys 0.59.0",
 ]

{running_process-4.6.2 → running_process-4.6.4}/Cargo.toml

@@ -3,7 +3,7 @@ resolver = "2"
 members = ["crates/running-process", "crates/running-process-py", "crates/test-watchdog"]
 
 [workspace.package]
-version = "4.6.2"
+version = "4.6.4"
 edition = "2021"
 rust-version = "1.85"
 license = "BSD-3-Clause"

{running_process-4.6.2 → running_process-4.6.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: running_process
-Version: 4.6.2
+Version: 4.6.4
 License-File: LICENSE
 Summary: A Rust-backed subprocess wrapper with split stdout/stderr streaming
 Home-Page: https://github.com/zackees/running-process
@@ -430,6 +430,36 @@ PTY mode is intentionally more conservative:
 
 `./test` runs the Rust tests, rebuilds the native extension with the unoptimized `dev` profile, runs the non-live Python tests, and then runs the `@pytest.mark.live` coverage that exercises real OS process and signal behavior.
 
+### Repository Dylint
+
+The native Linux x86 consolidated preflight runs the repository-owned
+`running_process_env_literal` lint. It rejects direct string literals for
+`RUNNING_PROCESS_*` environment controls in `std::env` calls, keeping broker
+escape hatches and test seams tied to their canonical constants. The lint
+library, `cargo-dylint`, and `dylint-link` are pinned to Dylint `6.0.1`; the
+library and CI both use `nightly-2026-04-16`.
+
+To run the same gate locally:
+
+```bash
+soldr rustup toolchain install nightly-2026-04-16 --profile minimal \
+  --component rustc-dev --component llvm-tools-preview
+uvx soldr cargo install cargo-dylint@6.0.1 dylint-link@6.0.1 --locked
+(
+  cd lints/running-process-env-literal
+  CARGO_TARGET_DIR=../../target/dylint RUSTUP_TOOLCHAIN=nightly-2026-04-16 \
+    uvx soldr cargo test --locked
+)
+CARGO_TARGET_DIR=target/dylint RUSTUP_TOOLCHAIN=nightly-2026-04-16 \
+  uvx soldr cargo dylint --all --workspace
+```
+
+The first check exercises the negative UI fixture and proves the lint rejects
+a literal control name. The second checks the workspace. CI gives the exact
+tool binaries and nightly target directory dedicated persistent caches and
+runs the gate once, rather than adding a cold Dylint build to every platform
+job.
+
 On local developer machines, `./test` also runs the Linux Docker preflight so Windows and macOS development catches Linux wheel, lint, and non-live pytest regressions before push. GitHub-hosted Actions skip that Docker-only preflight and run the native platform suite directly.
 
 For a live-only test run with the timeout crash watchdog and automatic thread

{running_process-4.6.2 → running_process-4.6.4}/README.md

@@ -416,6 +416,36 @@ PTY mode is intentionally more conservative:
 
 `./test` runs the Rust tests, rebuilds the native extension with the unoptimized `dev` profile, runs the non-live Python tests, and then runs the `@pytest.mark.live` coverage that exercises real OS process and signal behavior.
 
+### Repository Dylint
+
+The native Linux x86 consolidated preflight runs the repository-owned
+`running_process_env_literal` lint. It rejects direct string literals for
+`RUNNING_PROCESS_*` environment controls in `std::env` calls, keeping broker
+escape hatches and test seams tied to their canonical constants. The lint
+library, `cargo-dylint`, and `dylint-link` are pinned to Dylint `6.0.1`; the
+library and CI both use `nightly-2026-04-16`.
+
+To run the same gate locally:
+
+```bash
+soldr rustup toolchain install nightly-2026-04-16 --profile minimal \
+  --component rustc-dev --component llvm-tools-preview
+uvx soldr cargo install cargo-dylint@6.0.1 dylint-link@6.0.1 --locked
+(
+  cd lints/running-process-env-literal
+  CARGO_TARGET_DIR=../../target/dylint RUSTUP_TOOLCHAIN=nightly-2026-04-16 \
+    uvx soldr cargo test --locked
+)
+CARGO_TARGET_DIR=target/dylint RUSTUP_TOOLCHAIN=nightly-2026-04-16 \
+  uvx soldr cargo dylint --all --workspace
+```
+
+The first check exercises the negative UI fixture and proves the lint rejects
+a literal control name. The second checks the workspace. CI gives the exact
+tool binaries and nightly target directory dedicated persistent caches and
+runs the gate once, rather than adding a cold Dylint build to every platform
+job.
+
 On local developer machines, `./test` also runs the Linux Docker preflight so Windows and macOS development catches Linux wheel, lint, and non-live pytest regressions before push. GitHub-hosted Actions skip that Docker-only preflight and run the native platform suite directly.
 
 For a live-only test run with the timeout crash watchdog and automatic thread

{running_process-4.6.2 → running_process-4.6.4}/crates/running-process/build.rs

@@ -1,6 +1,9 @@
 use std::path::Path;
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // cargo-llvm-cov sets this cfg while linking LLVM's profiling runtime.
+    println!("cargo:rustc-check-cfg=cfg(coverage)");
+
     // Without these, edits to the .proto don't reliably retrigger
     // codegen on incremental builds.
     println!("cargo:rerun-if-changed=proto/daemon.proto");

{running_process-4.6.2 → running_process-4.6.4}/crates/running-process/src/README.md

@@ -4,7 +4,7 @@ Top-level modules of the published `running-process` crate. Feature gating is
 described in the repo-root `CLAUDE.md` ("Rust workspace" section).
 
 - `lib.rs` / `public_symbols.rs` — crate surface and re-exports
-- `environment.rs` — user baseline environment (Windows `CreateEnvironmentBlock`, Unix snapshot)
+- `environment.rs` — user baseline environment (Windows `CreateEnvironmentBlock`, Unix login reconstruction)
 - `spawn.rs`, `spawn_imp_unix.rs`, `spawn_imp_windows.rs` — process spawn implementations
 - `process_tree.rs` — process-tree enumeration and tree kill
 - `containment.rs` — Job Objects / process-group containment

{running_process-4.6.2 → running_process-4.6.4}/crates/running-process/src/bin/running-process-broker-v2.rs

@@ -10,8 +10,8 @@
 //!    earlier integration tests.
 //! 2. **Persistent accept loop** — each accepted connection spawns
 //!    a thread that handles the Hello round-trip. The accept loop
-//!    is bounded only by the OS's pending-connection backlog;
-//!    in-flight handlers are bounded by the OS thread cap.
+//!    polls with bounded latency so Unix SIGTERM/SIGINT can request a
+//!    normal shutdown; in-flight handlers are drained with a deadline.
 //! 3. **ServiceDefinitionLoader integration** — on each Hello, look
 //!    up `hello.service_name` via the default v2 service-definition
 //!    directory ([`ServiceDefinitionLoader::default_root`]). Reject
@@ -33,7 +33,7 @@
 //!   `broker-v2-scaffold`.
 //!
 //! Future slices:
-//! - SIGTERM / Ctrl+C graceful shutdown (drain in-flight handlers).
+//! - Windows console-event graceful shutdown.
 //! - Backend-pipe resolution + adopt forwarding.
 //! - Single-instance lock (refuse start if another broker is bound).
 //! - Refuse-privileged-run guard (port from v1).
@@ -41,12 +41,13 @@
 use std::env;
 use std::io::Write;
 use std::process::ExitCode;
+use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
 use std::sync::Arc;
-use std::sync::atomic::{AtomicUsize, Ordering};
 use std::thread;
+use std::time::{Duration, Instant};
 
 use interprocess::local_socket::traits::{Listener as _, Stream as _};
-use interprocess::local_socket::ListenerOptions;
+use interprocess::local_socket::{ListenerNonblockingMode, ListenerOptions};
 use prost::Message;
 use running_process::broker::lifecycle::names_v2::v2_program_pipe;
 use running_process::broker::lifecycle::privilege::refuse_privileged_run;
@@ -56,8 +57,8 @@ use running_process::broker::protocol::{
     ENVELOPE_VERSION,
 };
 use running_process::broker::protocol_v2::ServiceDefinitionLoader;
-use running_process::broker::server::service_def_loader::ServiceDefinitionError;
 use running_process::broker::server::deadline_stream::{hello_read_deadline, DeadlineStream};
+use running_process::broker::server::service_def_loader::ServiceDefinitionError;
 
 /// Default program name when `--program` is not passed. Matches the
 /// slice-3c scaffold so existing integration tests keep working.
@@ -68,6 +69,59 @@ const SCAFFOLD_PIPE_IDX: u32 = 0;
 /// cap is the hard upper bound but we want backpressure before that.
 const MAX_INFLIGHT_HANDLERS: usize = 256;
 const MAX_INFLIGHT_HANDLERS_ENV: &str = "RUNNING_PROCESS_BROKER_MAX_INFLIGHT_HANDLERS";
+const ACCEPT_POLL_INTERVAL: Duration = Duration::from_millis(20);
+const HANDLER_DRAIN_TIMEOUT: Duration = Duration::from_secs(5);
+
+#[cfg(unix)]
+static SIGNAL_SHUTDOWN_REQUESTED: AtomicBool = AtomicBool::new(false);
+
+#[cfg(unix)]
+extern "C" fn record_shutdown_signal(_signal: libc::c_int) {
+    // Async-signal-safe by construction: do not allocate, log, join threads,
+    // or call the LLVM profile runtime from this handler.
+    SIGNAL_SHUTDOWN_REQUESTED.store(true, Ordering::Relaxed);
+}
+
+#[cfg(unix)]
+fn install_shutdown_signal_handlers() -> std::io::Result<()> {
+    SIGNAL_SHUTDOWN_REQUESTED.store(false, Ordering::Relaxed);
+    for signal in [libc::SIGTERM, libc::SIGINT] {
+        // SAFETY: `record_shutdown_signal` has C ABI, lives for the process
+        // lifetime, and performs only an atomic store.
+        let previous = unsafe {
+            libc::signal(
+                signal,
+                record_shutdown_signal as *const () as libc::sighandler_t,
+            )
+        };
+        if previous == libc::SIG_ERR {
+            return Err(std::io::Error::last_os_error());
+        }
+    }
+    Ok(())
+}
+
+#[cfg(coverage)]
+unsafe extern "C" {
+    fn __llvm_profile_write_file() -> libc::c_int;
+}
+
+fn flush_coverage_profile() -> Result<(), String> {
+    #[cfg(coverage)]
+    {
+        // SAFETY: cargo-llvm-cov links this process with LLVM's profiling
+        // runtime. This call occurs after the signal handler has returned and
+        // after handler threads have been drained, in ordinary Rust control
+        // flow.
+        let result = unsafe { __llvm_profile_write_file() };
+        if result != 0 {
+            return Err(format!(
+                "__llvm_profile_write_file returned nonzero status {result}"
+            ));
+        }
+    }
+    Ok(())
+}
 
 fn max_inflight_handlers() -> usize {
     std::env::var(MAX_INFLIGHT_HANDLERS_ENV)
@@ -151,14 +205,14 @@ fn main() -> ExitCode {
     // would bind the v2 pipe in a namespace other users can't reach
     // AND would create privileged sockets that downstream daemons
     // get adopted into. Mirrors v1's `running-process-broker-v1`
-    // startup check exactly. The `RUNNING_PROCESS_ALLOW_PRIVILEGED`
+    // startup check exactly. The `RUNNING_PROCESS_BROKER_ALLOW_PRIVILEGED`
     // env var is honored for isolated test environments that
     // intentionally exercise privileged startup behavior.
     if let Err(err) = refuse_privileged_run() {
         eprintln!(
             "running-process-broker-v2: refusing privileged startup: {err}. \
              Run as an unprivileged user, or set \
-             RUNNING_PROCESS_ALLOW_PRIVILEGED=1 for isolated test environments only."
+             RUNNING_PROCESS_BROKER_ALLOW_PRIVILEGED=1 for isolated test environments only."
         );
         return ExitCode::from(77); // EX_NOPERM
     }
@@ -252,7 +306,23 @@ fn main() -> ExitCode {
     let exit_code = if opts.once {
         accept_one(&listener, Arc::clone(&loader))
     } else {
-        accept_loop(&listener, Arc::clone(&loader), Arc::clone(&inflight))
+        #[cfg(unix)]
+        if let Err(err) = install_shutdown_signal_handlers() {
+            eprintln!("running-process-broker-v2: install shutdown signal handlers failed: {err}");
+            return ExitCode::from(1);
+        }
+
+        #[cfg(unix)]
+        let shutdown = &SIGNAL_SHUTDOWN_REQUESTED;
+        #[cfg(not(unix))]
+        let shutdown = &AtomicBool::new(false);
+
+        accept_loop(
+            &listener,
+            Arc::clone(&loader),
+            Arc::clone(&inflight),
+            shutdown,
+        )
     };
 
     #[cfg(unix)]
@@ -260,22 +330,34 @@ fn main() -> ExitCode {
         let _ = std::fs::remove_file(&socket_path);
     }
 
+    if let Err(err) = flush_coverage_profile() {
+        eprintln!("running-process-broker-v2: coverage profile flush failed: {err}");
+        return ExitCode::from(1);
+    }
+
     exit_code
 }
 
 /// Persistent accept loop. Spawns one handler thread per accepted
-/// connection, bounded by `MAX_INFLIGHT_HANDLERS`. Returns `ExitCode`
-/// only on terminal accept failure (the loop itself never returns
-/// success — production exit is via SIGTERM, a follow-up slice).
+/// connection, bounded by `MAX_INFLIGHT_HANDLERS`. A nonblocking listener
+/// makes the shutdown flag observable within [`ACCEPT_POLL_INTERVAL`].
 fn accept_loop(
     listener: &interprocess::local_socket::Listener,
     loader: Arc<ServiceDefinitionLoader>,
     inflight: Arc<AtomicUsize>,
+    shutdown: &AtomicBool,
 ) -> ExitCode {
+    if let Err(err) = listener.set_nonblocking(ListenerNonblockingMode::Accept) {
+        eprintln!("running-process-broker-v2: set listener nonblocking failed: {err}");
+        return ExitCode::from(1);
+    }
+
     let max_inflight = max_inflight_handlers();
+    let mut handlers = Vec::new();
     loop {
-        match listener.accept() {
-            Ok(stream) => {
+        reap_finished_handlers(&mut handlers);
+        match poll_accept_until_shutdown(shutdown, || listener.accept()) {
+            Ok(Some(stream)) => {
                 // Backpressure: refuse to spawn if we're already at the cap.
                 // The peer's blocking read on the Hello-reply socket will
                 // see EOF when this branch closes the stream.
@@ -300,20 +382,28 @@ fn accept_loop(
                             Ok(svc) => println!(
                                 "running-process-broker-v2 Hello service={svc:?} negotiated",
                             ),
-                            Err(err) => eprintln!(
-                                "running-process-broker-v2 Hello handler failed: {err}"
-                            ),
+                            Err(err) => {
+                                eprintln!("running-process-broker-v2 Hello handler failed: {err}")
+                            }
                         }
                     });
-                if let Err(err) = spawn_result {
-                    eprintln!(
-                        "running-process-broker-v2: thread spawn failed: {err}; \
-                         dropping connection"
-                    );
-                    // Decrement here since the spawned thread never ran.
-                    inflight.fetch_sub(1, Ordering::SeqCst);
+                match spawn_result {
+                    Ok(handler) => handlers.push(handler),
+                    Err(err) => {
+                        eprintln!(
+                            "running-process-broker-v2: thread spawn failed: {err}; \
+                             dropping connection"
+                        );
+                        // Decrement here since the spawned thread never ran.
+                        inflight.fetch_sub(1, Ordering::SeqCst);
+                    }
                 }
             }
+            Ok(None) => {
+                println!("running-process-broker-v2: shutdown requested; draining handlers");
+                drain_handlers(&mut handlers, HANDLER_DRAIN_TIMEOUT);
+                return ExitCode::SUCCESS;
+            }
             Err(err) => {
                 // accept() errors are typically fatal (listener died);
                 // exit so a supervisor can restart us.
@@ -324,6 +414,55 @@ fn accept_loop(
     }
 }
 
+fn poll_accept_until_shutdown<T>(
+    shutdown: &AtomicBool,
+    mut accept: impl FnMut() -> std::io::Result<T>,
+) -> std::io::Result<Option<T>> {
+    while !shutdown.load(Ordering::Relaxed) {
+        match accept() {
+            Ok(value) => return Ok(Some(value)),
+            Err(err) if err.kind() == std::io::ErrorKind::WouldBlock => {
+                thread::sleep(ACCEPT_POLL_INTERVAL);
+            }
+            Err(err) if err.kind() == std::io::ErrorKind::Interrupted => {}
+            Err(err) => return Err(err),
+        }
+    }
+    Ok(None)
+}
+
+fn reap_finished_handlers(handlers: &mut Vec<thread::JoinHandle<()>>) {
+    let mut index = 0;
+    while index < handlers.len() {
+        if handlers[index].is_finished() {
+            let handler = handlers.swap_remove(index);
+            if handler.join().is_err() {
+                eprintln!("running-process-broker-v2: handler thread panicked");
+            }
+        } else {
+            index += 1;
+        }
+    }
+}
+
+fn drain_handlers(handlers: &mut Vec<thread::JoinHandle<()>>, timeout: Duration) {
+    let deadline = Instant::now() + timeout;
+    while !handlers.is_empty() && Instant::now() < deadline {
+        reap_finished_handlers(handlers);
+        if !handlers.is_empty() {
+            thread::sleep(ACCEPT_POLL_INTERVAL);
+        }
+    }
+    reap_finished_handlers(handlers);
+    if !handlers.is_empty() {
+        eprintln!(
+            "running-process-broker-v2: handler drain timed out after {timeout:?}; \
+             detaching {} handler(s)",
+            handlers.len()
+        );
+    }
+}
+
 /// One-shot accept (replaces the prior scaffold behavior; used by
 /// `--once` for tests + by the slice-3c integration test).
 fn accept_one(
@@ -643,6 +782,35 @@ mod tests {
         }
     }
 
+    #[test]
+    fn accept_poll_exits_without_accepting_after_shutdown_request() {
+        let shutdown = AtomicBool::new(true);
+        let result = poll_accept_until_shutdown(&shutdown, || -> std::io::Result<()> {
+            panic!("accept must not run after shutdown")
+        })
+        .unwrap();
+        assert!(result.is_none());
+    }
+
+    #[test]
+    fn accept_poll_observes_shutdown_while_listener_would_block() {
+        let shutdown = Arc::new(AtomicBool::new(false));
+        let setter = Arc::clone(&shutdown);
+        let signaler = thread::spawn(move || {
+            thread::sleep(ACCEPT_POLL_INTERVAL);
+            setter.store(true, Ordering::Relaxed);
+        });
+        let start = Instant::now();
+        let result = poll_accept_until_shutdown(&shutdown, || -> std::io::Result<()> {
+            Err(std::io::ErrorKind::WouldBlock.into())
+        })
+        .unwrap();
+
+        signaler.join().unwrap();
+        assert!(result.is_none());
+        assert!(start.elapsed() < Duration::from_secs(1));
+    }
+
     #[test]
     fn parse_cli_defaults() {
         let args = vec!["bin".to_owned()];
@@ -654,7 +822,11 @@ mod tests {
 
     #[test]
     fn parse_cli_program_arg() {
-        let args = vec!["bin".to_owned(), "--program".to_owned(), "zccache".to_owned()];
+        let args = vec![
+            "bin".to_owned(),
+            "--program".to_owned(),
+            "zccache".to_owned(),
+        ];
         let opts = parse_cli(&args).unwrap();
         assert_eq!(opts.program, "zccache");
     }
@@ -742,11 +914,7 @@ mod tests {
         match reply.result {
             Some(hello_reply::Result::Refused(r)) => {
                 assert_eq!(r.code, ErrorCode::ErrorVersionBlocked as i32);
-                assert!(
-                    r.reason.contains("allow_list"),
-                    "got: {}",
-                    r.reason
-                );
+                assert!(r.reason.contains("allow_list"), "got: {}", r.reason);
             }
             other => panic!("expected Refused, got {other:?}"),
         }

{running_process-4.6.2 → running_process-4.6.4}/crates/running-process/src/broker/manifest.rs

@@ -30,6 +30,9 @@ pub const CACHE_MANIFEST_MEDIA_TYPE: &str = "application/vnd.running-process.cac
 /// Highest manifest schema this crate understands.
 pub const SUPPORTED_MANIFEST_SCHEMA_VERSION: u32 = 1;
 
+/// Test/development override for the central manifest registry directory.
+pub const RUNNING_PROCESS_MANIFEST_DIR_ENV: &str = "RUNNING_PROCESS_MANIFEST_DIR";
+
 /// Errors returned by manifest persistence and validation.
 #[derive(Debug, thiserror::Error)]
 pub enum ManifestError {
@@ -178,7 +181,7 @@ pub fn scan_central(registry_dir: &Path) -> Vec<ManifestScanEntry> {
 /// `RUNNING_PROCESS_MANIFEST_DIR` is honored as a test/development
 /// override. Production callers should leave it unset.
 pub fn central_registry_dir() -> PathBuf {
-    if let Some(path) = std::env::var_os("RUNNING_PROCESS_MANIFEST_DIR") {
+    if let Some(path) = std::env::var_os(RUNNING_PROCESS_MANIFEST_DIR_ENV) {
         return PathBuf::from(path);
     }
 

{running_process-4.6.2 → running_process-4.6.4}/crates/running-process/src/containment.rs

@@ -7,7 +7,10 @@
 //! responsibility is now scoped to:
 //!
 //! - holding an optional `originator` label,
-//! - injecting [`ORIGINATOR_ENV_VAR`] into every child the group spawns,
+//! - injecting [`ORIGINATOR_ENV_VAR`] into every *contained* child the group
+//!   spawns, and stripping it from every *daemon* child (a daemon outlives its
+//!   spawner, so it must not be attributable to it — see
+//!   [`ContainedProcessGroup::spawn_daemon`]),
 //! - dispatching to either [`crate::spawn()`] or [`crate::spawn_daemon`].
 //!
 //! # `RUNNING_PROCESS_ORIGINATOR` environment variable
@@ -107,19 +110,111 @@ impl ContainedProcessGroup {
     /// handle list, and survives the returned [`DaemonChild`] being
     /// dropped. To terminate, call [`DaemonChild::kill`].
     ///
-    /// The parent-child association (this group's originator env var)
-    /// is injected into the child before the spawn so cross-process
-    /// tracking can resolve the spawned daemon back to its parent.
+    /// The originator env var is deliberately **stripped**, never injected.
+    ///
+    /// A daemon outlives the process that happened to start it — that is the
+    /// entire point of spawning one. Tagging it `TOOL:<spawner pid>` makes it
+    /// indistinguishable from an abandoned descendant, so as soon as the
+    /// spawner exits, any originator-based reaper sees a live process whose
+    /// originator is dead and kills it. Build-cache daemons (zccache, sccache)
+    /// are the common casualty: they are started lazily by whichever compiler
+    /// invocation happens to run first, inherit that session's tag, and get
+    /// reaped when it ends — taking the warm cache down with them.
+    ///
+    /// This also restores the intent of the daemon environment policy.
+    /// [`crate::EnvironmentPolicy::Auto`] resolves to `UserBaseline` for
+    /// daemons, which rebuilds the environment from the user's login identity
+    /// and drops process-local variables. Explicit `command.env(...)` entries
+    /// are applied *last*, so injecting here silently defeated that policy for
+    /// this one variable.
     pub fn spawn_daemon(&self, command: &mut Command) -> Result<DaemonChild, std::io::Error> {
-        self.inject_originator_env(command);
+        Self::strip_originator_env(command);
         free_spawn_daemon(command)
     }
+
+    /// Remove the originator tag from `command`. Split out from
+    /// [`Self::spawn_daemon`] so the policy is unit-testable without
+    /// spawning a real detached process.
+    fn strip_originator_env(command: &mut Command) {
+        command.env_remove(ORIGINATOR_ENV_VAR);
+    }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
 
+    fn originator_entry(command: &Command) -> Option<Option<&std::ffi::OsStr>> {
+        let key = std::ffi::OsStr::new(ORIGINATOR_ENV_VAR);
+        command.get_envs().find(|(k, _)| *k == key).map(|(_, v)| v)
+    }
+
+    /// The two halves must compose: a daemon drops the originator tag *and*
+    /// carries the positive marker. Absence alone is ambiguous — it also
+    /// describes a process whose environment was clobbered — so a reaper
+    /// needs the declaration, not just the missing tag (clud#522).
+    #[test]
+    fn daemon_declares_itself_and_drops_the_originator_tag() {
+        let mut cmd = Command::new("echo");
+        cmd.env(ORIGINATOR_ENV_VAR, "CLUD:12345");
+        ContainedProcessGroup::strip_originator_env(&mut cmd);
+        crate::spawn::mark_as_daemon(&mut cmd);
+
+        assert_eq!(
+            originator_entry(&cmd),
+            Some(None),
+            "the originator tag must still be removed"
+        );
+        let marker = std::ffi::OsStr::new(crate::DAEMON_MARKER_ENV_VAR);
+        assert_eq!(
+            cmd.get_envs()
+                .find(|(k, _)| *k == marker)
+                .and_then(|(_, v)| v),
+            Some(std::ffi::OsStr::new("1")),
+            "a daemon must positively declare itself"
+        );
+    }
+
+    /// A daemon must not carry its spawner's originator tag: it outlives the
+    /// spawner, so the tag turns it into reaper bait the moment the spawner
+    /// exits. `env_remove` must win even when the caller explicitly set it.
+    #[test]
+    fn spawn_daemon_strips_originator_env() {
+        let mut cmd = Command::new("echo");
+        cmd.env(ORIGINATOR_ENV_VAR, "CLUD:12345");
+        ContainedProcessGroup::strip_originator_env(&mut cmd);
+        assert_eq!(
+            originator_entry(&cmd),
+            Some(None),
+            "daemon command must carry an explicit removal of {ORIGINATOR_ENV_VAR}"
+        );
+    }
+
+    /// The stripping must be unconditional — a group *with* an originator is
+    /// exactly the case that used to inject the tag into daemons.
+    #[test]
+    fn spawn_daemon_strips_originator_even_for_tagged_group() {
+        let group = ContainedProcessGroup::with_originator("CLUD").unwrap();
+        assert!(group.originator().is_some());
+        let mut cmd = Command::new("echo");
+        ContainedProcessGroup::strip_originator_env(&mut cmd);
+        assert_eq!(originator_entry(&cmd), Some(None));
+    }
+
+    /// Contrast: *contained* children keep the tag. That is what makes the
+    /// on-exit reaper able to find genuinely abandoned descendants.
+    #[test]
+    fn contained_spawn_still_injects_originator_env() {
+        let group = ContainedProcessGroup::with_originator("CLUD").unwrap();
+        let mut cmd = Command::new("echo");
+        group.inject_originator_env(&mut cmd);
+        let expected = format!("CLUD:{}", std::process::id());
+        assert_eq!(
+            originator_entry(&cmd),
+            Some(Some(std::ffi::OsStr::new(expected.as_str())))
+        );
+    }
+
     #[test]
     fn contained_process_group_creates_successfully() {
         let group = ContainedProcessGroup::new();