Diff in \\?\C:\Users\decid\Documents\projects\spt-core\.worktrees\probe-cap-count-not-clock\crates\spt-daemon\src\servicehost.rs:414: /// …and the CLI capability: where `spt` is and which home it must speak to, so /// `spt send` from a supervised service is a declared capability rather than a /// property of whatever `PATH` and profile the daemon happened to inherit. -fn service_env_at( - home: &Path, - option: &str, - service_dir: &Path, -) -> Vec<(String, String)> { +fn service_env_at(home: &Path, option: &str, service_dir: &Path) -> Vec<(String, String)> { let mut env = vec![ (ENV_SERVICE_OPTION.to_string(), option.to_string()), ( Diff in \\?\C:\Users\decid\Documents\projects\spt-core\.worktrees\probe-cap-count-not-clock\crates\spt-daemon\src\servicehost.rs:425: ENV_SERVICE_DIR.to_string(), service_dir.display().to_string(), ), - ( - ENV_SERVICE_SPT_HOME.to_string(), - home.display().to_string(), - ), + (ENV_SERVICE_SPT_HOME.to_string(), home.display().to_string()), ]; // Best-effort by necessity: `current_exe` can fail (a deleted or unreadable // image). An ABSENT var is the honest answer there — an adapter can then say Diff in \\?\C:\Users\decid\Documents\projects\spt-core\.worktrees\probe-cap-count-not-clock\crates\spt-daemon\src\servicehost.rs:435: // so. A var pointing at a guess would make every downstream failure look like // the adapter's. if let Ok(exe) = std::env::current_exe() { - env.push(( - ENV_SERVICE_SPT_BIN.to_string(), - exe.display().to_string(), - )); + env.push((ENV_SERVICE_SPT_BIN.to_string(), exe.display().to_string())); } env } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\.worktrees\probe-cap-count-not-clock\crates\spt-daemon\src\servicehost.rs:482: ) -> Result, String> { let keys = std::collections::BTreeMap::from([ ("adapter_name".to_string(), adapter_name.to_string()), - ( - "adapter_dir".to_string(), - install_dir.display().to_string(), - ), + ("adapter_dir".to_string(), install_dir.display().to_string()), ]); // [impl->REQ-HAZARD-TEMPLATE-ARGV-FILL] tokenize-template-then-fill-each: a // multi-word/quote/semicolon {key} value is exactly one argv element. Diff in \\?\C:\Users\decid\Documents\projects\spt-core\.worktrees\probe-cap-count-not-clock\crates\spt-daemon\src\servicehost.rs:615: /// previous instance is PROVEN gone (or provably never was): an unresolved /// sweep blocks the spawn rather than risking two live instances. pub fn clear_to_spawn(&self) -> bool { - matches!(self, Self::NoRecord | Self::AlreadyDead | Self::Killed | Self::NotOurs(_)) + matches!( + self, + Self::NoRecord | Self::AlreadyDead | Self::Killed | Self::NotOurs(_) + ) } } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\.worktrees\probe-cap-count-not-clock\crates\spt-daemon\src\servicehost.rs:776: // Each run gets a clean sheet: a fault must be explained by THIS run's // output, never by a previous one's still sitting in the file. reclaim_capture(&capture); - let mut child = - match crate::daemon::detached_no_inherit_env( - program, - args, - &env, - SERVICE_ENV_SCRUB, - Some(&capture), - ) { - Ok(c) => c, - Err(e) => { - let e = format!("spawn {program}: {e}"); - eprintln!("SERVICE_STARTUP_FAULT:{option}: {e}"); - return Some(StandDown { - latch: Latch::StartupFault, - detail: Some(e), - }); - } - }; + let mut child = match crate::daemon::detached_no_inherit_env( + program, + args, + &env, + SERVICE_ENV_SCRUB, + Some(&capture), + ) { + Ok(c) => c, + Err(e) => { + let e = format!("spawn {program}: {e}"); + eprintln!("SERVICE_STARTUP_FAULT:{option}: {e}"); + return Some(StandDown { + latch: Latch::StartupFault, + detail: Some(e), + }); + } + }; // Park the kill handle BEFORE the wait: a daemon that dies mid-run must // leave its successor something path-verifiable to reap. let image = spt_store::proc::exe_path(child.pid()); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\.worktrees\probe-cap-count-not-clock\crates\spt-daemon\src\servicehost.rs:1037: /// The latch currently suppressing this option, [`Latch::None`] if none. // [impl->REQ-RESIDENT-SERVICE] pub fn latch(&self, option: &str) -> Latch { - self.stand_down(option) - .map(|s| s.latch) - .unwrap_or_default() + self.stand_down(option).map(|s| s.latch).unwrap_or_default() } /// The whole stand-down record — the latch AND the evidence for it. This is Diff in \\?\C:\Users\decid\Documents\projects\spt-core\.worktrees\probe-cap-count-not-clock\crates\spt-daemon\src\servicehost.rs:1083: pub fn is_held(&self, option: &str) -> bool { let key = spt_store::perch::encode_adapter_option(option); let map = self.holds.lock().unwrap_or_else(|p| p.into_inner()); - map.get(&key) - .is_some_and(|f| f.load(Ordering::SeqCst)) + map.get(&key).is_some_and(|f| f.load(Ordering::SeqCst)) } /// Engage the hold. Step 1 of [`quiesce_order`], and it must land BEFORE the Diff in \\?\C:\Users\decid\Documents\projects\spt-core\.worktrees\probe-cap-count-not-clock\crates\spt-daemon\src\servicehost.rs:1299: // Resolve through the OPTION seam even for a bare name, so this path is // option-general by construction rather than adapter-only with an // option-shaped signature bolted on later. - let Ok(manifest) = spt_runtime::registry::resolve_option_in(registered, adapters_dir, &option) + let Ok(manifest) = + spt_runtime::registry::resolve_option_in(registered, adapters_dir, &option) else { continue; // unresolvable manifest: not a service question }; Diff in \\?\C:\Users\decid\Documents\projects\spt-core\.worktrees\probe-cap-count-not-clock\crates\spt-daemon\src\servicehost.rs:1328: // and the operator asking "why will my service not start" would get the // fault's name and nothing else. let mut detail = match decision.outcome { - ServiceOutcome::StartupFault | ServiceOutcome::Latched => { - stood.and_then(|s| s.detail) - } + ServiceOutcome::StartupFault | ServiceOutcome::Latched => stood.and_then(|s| s.detail), _ => None, }; let outcome = match decision.outcome { Diff in \\?\C:\Users\decid\Documents\projects\spt-core\.worktrees\probe-cap-count-not-clock\crates\spt-daemon\src\servicehost.rs:2299: }; std::fs::write(dir.join(shipped), b"").unwrap(); - let tokens = fill_service_command("cc", dir, &svc("svcbin --serve {adapter_name}")).unwrap(); + let tokens = + fill_service_command("cc", dir, &svc("svcbin --serve {adapter_name}")).unwrap(); assert_eq!( tokens[0], dir.join(shipped).display().to_string(), Diff in \\?\C:\Users\decid\Documents\projects\spt-core\.worktrees\probe-cap-count-not-clock\crates\spt-daemon\src\servicehost.rs:2339: let home = Path::new("/spt-home"); let a_dir = spt_store::perch::resolve_service_dir_in(home, "cc:dev"); let b_dir = spt_store::perch::resolve_service_dir_in(home, "cc_dev"); - assert_ne!(a_dir, b_dir, "the collision-adversarial pair must stay apart"); + assert_ne!( + a_dir, b_dir, + "the collision-adversarial pair must stay apart" + ); let env = service_env_at(home, "cc:dev", &a_dir); assert_eq!( Diff in \\?\C:\Users\decid\Documents\projects\spt-core\.worktrees\probe-cap-count-not-clock\crates\spt-daemon\src\servicehost.rs:2487: let tmp = tempfile::tempdir().unwrap(); let tokens: Vec = long_running().split(' ').map(String::from).collect(); let (program, args) = tokens.split_first().unwrap(); - let child = - crate::daemon::detached_no_inherit_env(program, args, &[], &[], None).expect("spawn orphan"); + let child = crate::daemon::detached_no_inherit_env(program, args, &[], &[], None) + .expect("spawn orphan"); let pid = child.pid(); // Park exactly what a supervisor parks, then FORGET the handle — this is // a dead daemon's orphan, which nobody holds a handle to. Diff in \\?\C:\Users\decid\Documents\projects\spt-core\.worktrees\probe-cap-count-not-clock\crates\spt-daemon\src\servicehost.rs:2495: let image = spt_store::proc::exe_path(pid); - assert!(image.is_some(), "the image oracle must answer for our own child"); + assert!( + image.is_some(), + "the image oracle must answer for our own child" + ); park_identity(tmp.path(), pid, image.as_deref()); drop(child); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\.worktrees\probe-cap-count-not-clock\crates\spt-daemon\src\servicehost.rs:2500: - assert_eq!(kill_orphan_service_at(tmp.path(), "cc"), OrphanSweep::Killed); + assert_eq!( + kill_orphan_service_at(tmp.path(), "cc"), + OrphanSweep::Killed + ); assert!( !spt_store::proc::is_process_alive(pid), "Killed is only reported when the post-kill read says so" Diff in \\?\C:\Users\decid\Documents\projects\spt-core\.worktrees\probe-cap-count-not-clock\crates\spt-daemon\src\servicehost.rs:2511: #[test] fn empty_and_dead_orphan_records_read_apart() { let tmp = tempfile::tempdir().unwrap(); - assert_eq!(kill_orphan_service_at(tmp.path(), "cc"), OrphanSweep::NoRecord); + assert_eq!( + kill_orphan_service_at(tmp.path(), "cc"), + OrphanSweep::NoRecord + ); park_identity(tmp.path(), 0, None); assert_eq!( kill_orphan_service_at(tmp.path(), "cc"), Diff in \\?\C:\Users\decid\Documents\projects\spt-core\.worktrees\probe-cap-count-not-clock\crates\spt-daemon\src\servicehost.rs:2679: }) }; assert!( - wait_until(|| read_parked_identity(&dir).is_some_and(|(pid, _)| { - pid != 0 && spt_store::proc::is_process_alive(pid) - })), + wait_until(|| read_parked_identity(&dir) + .is_some_and(|(pid, _)| { pid != 0 && spt_store::proc::is_process_alive(pid) })), "the supervised child never came up" ); let pid = read_parked_identity(&dir).unwrap().0; Diff in \\?\C:\Users\decid\Documents\projects\spt-core\.worktrees\probe-cap-count-not-clock\crates\spt-daemon\src\servicehost.rs:2900: let set = ServiceSet::new(); let params = ServiceParams::default(); - let out = reconcile_once(&adapters, ®istered, &set, Opportunity::Boot, None, ¶ms); - assert_eq!(out.len(), 1, "one candidate per registered adapter: {out:?}"); + let out = reconcile_once( + &adapters, + ®istered, + &set, + Opportunity::Boot, + None, + ¶ms, + ); + assert_eq!( + out.len(), + 1, + "one candidate per registered adapter: {out:?}" + ); assert_eq!(out[0].option, "a", "the RAW option is what is reported"); assert_eq!(out[0].outcome, ServiceOutcome::Started); - assert_eq!(out[0].detail, None, "a plain Started invents no reassurance"); + assert_eq!( + out[0].detail, None, + "a plain Started invents no reassurance" + ); assert!(set.contains("a")); let dir = spt_store::perch::resolve_service_dir("a"); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\.worktrees\probe-cap-count-not-clock\crates\spt-daemon\src\servicehost.rs:2914: ); let first = read_parked_identity(&dir).expect("parked").0; - let again = - reconcile_once(&adapters, ®istered, &set, Opportunity::Boot, None, ¶ms); + let again = reconcile_once( + &adapters, + ®istered, + &set, + Opportunity::Boot, + None, + ¶ms, + ); assert_eq!(again[0].outcome, ServiceOutcome::AlreadyRunning); assert_eq!(set.len(), 1, "one supervisor per option"); assert_eq!( Diff in \\?\C:\Users\decid\Documents\projects\spt-core\.worktrees\probe-cap-count-not-clock\crates\spt-daemon\src\servicehost.rs:2945: let set = ServiceSet::new(); let params = ServiceParams::default(); - let out = reconcile_once(&adapters, ®istered, &set, Opportunity::Boot, None, ¶ms); + let out = reconcile_once( + &adapters, + ®istered, + &set, + Opportunity::Boot, + None, + ¶ms, + ); assert_eq!(out[0].outcome, ServiceOutcome::BindDeferred); assert!( set.is_empty(), Diff in \\?\C:\Users\decid\Documents\projects\spt-core\.worktrees\probe-cap-count-not-clock\crates\spt-daemon\src\servicehost.rs:2952: "a deferred service is reported, never supervised" ); - let out = reconcile_once(&adapters, ®istered, &set, Opportunity::Bind, None, ¶ms); + let out = reconcile_once( + &adapters, + ®istered, + &set, + Opportunity::Bind, + None, + ¶ms, + ); assert_eq!(out[0].outcome, ServiceOutcome::Started); assert!(set.contains("a")); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\.worktrees\probe-cap-count-not-clock\crates\spt-daemon\src\servicehost.rs:2982: let set = ServiceSet::new(); let params = fast_latch_params(); - let out = reconcile_once(&adapters, ®istered, &set, Opportunity::Boot, None, ¶ms); + let out = reconcile_once( + &adapters, + ®istered, + &set, + Opportunity::Boot, + None, + ¶ms, + ); assert_eq!(out[0].outcome, ServiceOutcome::Started); assert!( Diff in \\?\C:\Users\decid\Documents\projects\spt-core\.worktrees\probe-cap-count-not-clock\crates\spt-daemon\src\servicehost.rs:2997: ); // A NON-clearing opportunity: report the suppression, raise nothing. - let out = reconcile_once(&adapters, ®istered, &set, Opportunity::Bind, None, ¶ms); + let out = reconcile_once( + &adapters, + ®istered, + &set, + Opportunity::Bind, + None, + ¶ms, + ); assert_eq!(out[0].outcome, ServiceOutcome::StartupFault); assert_eq!( out[0].detail, None, Diff in \\?\C:\Users\decid\Documents\projects\spt-core\.worktrees\probe-cap-count-not-clock\crates\spt-daemon\src\servicehost.rs:3263: assert!(!set.contains("a")); // THE ASSERTION: a clearing opportunity does not start a held option. - let out = reconcile_once(&adapters, ®istered, &set, Opportunity::Boot, None, ¶ms); + let out = reconcile_once( + &adapters, + ®istered, + &set, + Opportunity::Boot, + None, + ¶ms, + ); assert_eq!( out.iter().map(|o| o.outcome).collect::>(), [ServiceOutcome::Held], Diff in \\?\C:\Users\decid\Documents\projects\spt-core\.worktrees\probe-cap-count-not-clock\crates\spt-daemon\src\servicehost.rs:3749: )]; let set = ServiceSet::new(); let params = fast_latch_params(); - reconcile_once(&adapters, ®istered, &set, Opportunity::Boot, None, ¶ms); + reconcile_once( + &adapters, + ®istered, + &set, + Opportunity::Boot, + None, + ¶ms, + ); assert!( wait_until(|| set.latch("a") == Latch::StartupFault), "the fixture never latched" Diff in \\?\C:\Users\decid\Documents\projects\spt-core\.worktrees\probe-cap-count-not-clock\crates\spt-daemon\src\servicehost.rs:3810: crate::test_home::with_home(|home| { let (adapters, install) = sweep_dirs(home); let registered = vec![ - reg("a", &install, true, Some((long_running(), ServiceStart::Boot))), - reg("b", &install, false, Some((long_running(), ServiceStart::Bind))), + reg( + "a", + &install, + true, + Some((long_running(), ServiceStart::Boot)), + ), + reg( + "b", + &install, + false, + Some((long_running(), ServiceStart::Bind)), + ), reg("c", &install, true, None), ]; let set = ServiceSet::new(); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\.worktrees\probe-cap-count-not-clock\crates\spt-daemon\tests\daemon_e2e.rs:102: } } - /// The cross-OS echo child: reads stdin, writes each line back to stdout. fn echo_req() -> SpawnReq { #[cfg(unix)] Diff in \\?\C:\Users\decid\Documents\projects\spt-core\.worktrees\probe-cap-count-not-clock\crates\spt-store\src\daemon_inhibit.rs:166: assert!(stop_inhibited_at(home.path())); clear_stop_inhibit_at(home.path()).unwrap(); - assert!( - !stop_inhibited_at(home.path()), - "the intent verb clears it" - ); + assert!(!stop_inhibited_at(home.path()), "the intent verb clears it"); clear_stop_inhibit_at(home.path()).unwrap(); // idempotent } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\.worktrees\probe-cap-count-not-clock\crates\spt-store\src\daemon_inhibit.rs:222: ); drop(held); t.join().unwrap(); - assert!(entered.load(Ordering::SeqCst), "and it proceeds once released"); + assert!( + entered.load(Ordering::SeqCst), + "and it proceeds once released" + ); } }