Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\bin\xlate_choreo_fixture.rs:146: fn big_multiline_payload() -> String { let mut s = String::from("HEADSTART "); for i in 0..12 { - s.push_str(&format!("line-{i:02}-payload-body-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n")); + s.push_str(&format!( + "line-{i:02}-payload-body-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n" + )); } s.push_str("TAILEND"); s Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\applyhost.rs:402: } } // This version (or newer) is already the promoted, running image. - applied_version.map(|a| a >= staged_version).unwrap_or(false) + applied_version + .map(|a| a >= staged_version) + .unwrap_or(false) } /// Where the outgoing binary steps aside: a sibling `.old-` Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\applyhost.rs:676: /// Sign a single release (sk = [9u8;32], matching `stage`) and write the /// matching release-keys.json — WITHOUT staging, so a test controls the /// platform stamp itself. - fn sign_single(dir: &Path, version: u64, artifact: &[u8]) -> (SignedRelease, std::path::PathBuf) { + fn sign_single( + dir: &Path, + version: u64, + artifact: &[u8], + ) -> (SignedRelease, std::path::PathBuf) { let sk = SigningKey::from_bytes(&[9u8; 32]); let meta = ReleaseMetadata { version, Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\applyhost.rs:788: // Wire the supervisor signal; the verb now raises it and reports honored. let signal = Arc::new(crate::brainproc::BrainRestart::new()); - assert!(broker.set_brain_restart(Arc::clone(&signal)), "first wire wins"); + assert!( + broker.set_brain_restart(Arc::clone(&signal)), + "first wire wins" + ); let mut b2 = cold_connect_retry(&name); assert!( b2.request_brain_restart().expect("verb round-trips"), Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\applyhost.rs:881: // No served_broker — deliberately. A daemonless apply must not need one. let out = apply_staged_daemonless(&cache, &keys, &exe).expect("apply ok"); assert!( - matches!(out, ApplyStagedOutcome::AppliedDaemonless { version: 7, .. }), + matches!( + out, + ApplyStagedOutcome::AppliedDaemonless { version: 7, .. } + ), "got {out:?}" ); assert_eq!( Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\applyhost.rs:1103: .record_applied_state(&AppliedRecord::RolledBack { quarantine_version: 7, running_version: 6, - rollback_binary: exe.with_file_name("spt-binary.old-7").to_string_lossy().into(), + rollback_binary: exe + .with_file_name("spt-binary.old-7") + .to_string_lossy() + .into(), }) .unwrap(); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\applyhost.rs:1120: .record_applied_state(&AppliedRecord::RolledBack { quarantine_version: 7, running_version: 6, - rollback_binary: exe.with_file_name("spt-binary.old-7").to_string_lossy().into(), + rollback_binary: exe + .with_file_name("spt-binary.old-7") + .to_string_lossy() + .into(), }) .unwrap(); let out = apply_staged(&cache8, &keys8, &exe, &name).expect("ok"); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\attach.rs:49: use crate::access::{access_check, AccessDecision, InboundClass}; use crate::brain::{now_ms, Brain, BrokerEvent}; -use crate::effect::{Minter, MintedOp}; +use crate::effect::{MintedOp, Minter}; use crate::msg::{decode_bytes, encode_bytes}; /// Feed the resting-state machine at the attach edges (D9-2, REQ-INST-3): a Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\brain.rs:32: use interprocess::local_socket::{SendHalf, Stream}; use crate::codec::{read_frame, write_frame}; -use crate::frame::{Envelope, Role}; use crate::effect::MintedOp; +use crate::frame::{Envelope, Role}; use crate::msg::{ - decode_bytes, encode_bytes, AdapterApplyReq, AppliedEvent, BrainRestarted, BrokerImageReply, StallEvictsReply, DisplacedEvent, - EndpointInjected, EndpointInputReq, ErrorEvent, ExitEvent, - InputReq, - KillReq, NetDialReq, NetDialed, NetPresenceEvent, NetPresenceSubscribeReq, NetSent, - NetStatusReply, NetStreamData, NetStreamEof, NetStreamOpenReq, NetStreamOpened, NetStreamSendReq, - NetStreamSubscribeReq, NetStreamsReply, OutputEvent, MetMember, PairCodeSubmit, PairJoinReply, PairJoinReq, PairMeetReq, ResizeReq, - SessionsReply, SizeEvent, SpawnReq, Spawned, SubscribeOutcome, SubscribeReq, SubscribedReply, - ViewerEvictedEvent, - KIND_ADAPTER_APPLY, KIND_APPLIED, KIND_BRAIN_RESTART, KIND_BROKER_IMAGE, KIND_BROKER_IMAGE_REPLY, KIND_STALL_EVICTS, KIND_STALL_EVICTS_REPLY, KIND_VIEWER_EVICTED, - KIND_BRAIN_RESTARTED, KIND_DISPLACED, KIND_ENDPOINT_INJECTED, KIND_ENDPOINT_INPUT, KIND_ERROR, KIND_EXIT, KIND_INPUT, KIND_KILL, KIND_NET_DIAL, - KIND_NET_DIALED, KIND_NET_DIAL_LOOPBACK, KIND_NET_PRESENCE_EVENT, KIND_NET_PRESENCE_SUBSCRIBE, - KIND_NET_SENT, - KIND_NET_STATUS, KIND_NET_STATUS_REPLY, KIND_NET_STREAMS, KIND_NET_STREAMS_REPLY, - KIND_NET_STREAM_DATA, KIND_NET_STREAM_EOF, KIND_NET_STREAM_OPEN, KIND_NET_STREAM_OPENED, - KIND_MET_MEMBER, KIND_NET_STREAM_SEND, KIND_NET_STREAM_SUBSCRIBE, KIND_OUTPUT, KIND_PAIR_CODE_SUBMIT, KIND_PAIR_JOIN, KIND_PAIR_JOINED, KIND_PAIR_MEET, + decode_bytes, encode_bytes, AdapterApplyReq, AppliedEvent, BrainRestarted, BrokerImageReply, + DisplacedEvent, EndpointInjected, EndpointInputReq, ErrorEvent, ExitEvent, InputReq, KillReq, + MetMember, NetDialReq, NetDialed, NetPresenceEvent, NetPresenceSubscribeReq, NetSent, + NetStatusReply, NetStreamData, NetStreamEof, NetStreamOpenReq, NetStreamOpened, + NetStreamSendReq, NetStreamSubscribeReq, NetStreamsReply, OutputEvent, PairCodeSubmit, + PairJoinReply, PairJoinReq, PairMeetReq, ResizeReq, SessionsReply, SizeEvent, SpawnReq, + Spawned, StallEvictsReply, SubscribeOutcome, SubscribeReq, SubscribedReply, UnsubscribeReq, + ViewerEvictedEvent, KIND_ADAPTER_APPLY, KIND_APPLIED, KIND_BRAIN_RESTART, KIND_BRAIN_RESTARTED, + KIND_BROKER_IMAGE, KIND_BROKER_IMAGE_REPLY, KIND_DISPLACED, KIND_ENDPOINT_INJECTED, + KIND_ENDPOINT_INPUT, KIND_ERROR, KIND_EXIT, KIND_INPUT, KIND_KILL, KIND_MET_MEMBER, + KIND_NET_DIAL, KIND_NET_DIALED, KIND_NET_DIAL_LOOPBACK, KIND_NET_PRESENCE_EVENT, + KIND_NET_PRESENCE_SUBSCRIBE, KIND_NET_SENT, KIND_NET_STATUS, KIND_NET_STATUS_REPLY, + KIND_NET_STREAMS, KIND_NET_STREAMS_REPLY, KIND_NET_STREAM_DATA, KIND_NET_STREAM_EOF, + KIND_NET_STREAM_OPEN, KIND_NET_STREAM_OPENED, KIND_NET_STREAM_SEND, KIND_NET_STREAM_SUBSCRIBE, + KIND_OUTPUT, KIND_PAIR_CODE_SUBMIT, KIND_PAIR_JOIN, KIND_PAIR_JOINED, KIND_PAIR_MEET, KIND_RESIZE, KIND_SESSIONS, KIND_SESSIONS_REPLY, KIND_SIZE, KIND_SPAWN, KIND_SPAWNED, - KIND_SUBSCRIBE, KIND_SUBSCRIBED, KIND_UNSUBSCRIBE, UnsubscribeReq, + KIND_STALL_EVICTS, KIND_STALL_EVICTS_REPLY, KIND_SUBSCRIBE, KIND_SUBSCRIBED, KIND_UNSUBSCRIBE, + KIND_VIEWER_EVICTED, }; -use spt_net::net::attach::AttachIntent; use crate::transport::{send_hello, LocalSocketTransport}; +use spt_net::net::attach::AttachIntent; /// Wall-clock now in epoch milliseconds — the source for `gen_start` (matches /// the epoch-ms stamping used elsewhere in the tree; no date dependency). Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\brain.rs:921: // [impl->REQ-VIEWER-SKIP-TO-LIVE-ON-EVICT] pub fn attach_skip_to_live(&mut self, session_id: u64, by: Option<&str>) -> io::Result<()> { self.session_id = Some(session_id); - self.subscribe_with(session_id, u64::MAX, AttachIntent::Viewer, by.map(str::to_string))?; + self.subscribe_with( + session_id, + u64::MAX, + AttachIntent::Viewer, + by.map(str::to_string), + )?; self.session_cursors.insert(session_id, 0); self.next_seq = 0; Ok(()) Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\brain.rs:960: ) -> io::Result<()> { self.session_id = Some(session_id); self.next_seq = from_seq; - self.subscribe_with(session_id, from_seq, AttachIntent::Viewer, by.map(str::to_string))?; + self.subscribe_with( + session_id, + from_seq, + AttachIntent::Viewer, + by.map(str::to_string), + )?; self.session_cursors.insert(session_id, from_seq); Ok(()) } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\brain.rs:1018: self.next_seq } - /// Query the broker-owned net endpoint's status (D4a): node id, dialable /// address, conn count — or `enabled: false` on a net-less broker. Reads /// until the reply (consuming interleaved events like [`Brain::spawn_session`]). Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\brain.rs:1461: pub fn detach_session(&mut self, session_id: u64) -> io::Result<()> { self.send( KIND_UNSUBSCRIBE, - serde_json::to_value(UnsubscribeReq { session_id }) - .expect("UnsubscribeReq serializes"), + serde_json::to_value(UnsubscribeReq { session_id }).expect("UnsubscribeReq serializes"), ) } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\brain.rs:1677: // A FORWARD JUMP (seq 5, want 1) is a hard `output gap` error on the legacy // path — a cold brain treats a skipped seq as a lost chunk, never silently. stub.feed.send(output_envelope(sid, 5, b"jumped")).unwrap(); - let err = brain.read_event().expect_err("a cold brain rejects a forward gap"); + let err = brain + .read_event() + .expect_err("a cold brain rejects a forward gap"); assert_eq!(err.kind(), io::ErrorKind::InvalidData); assert!( err.to_string().contains("output gap"), Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\brain.rs:1723: stub.feed .send(output_envelope(sid, seq, format!("c{seq}").as_bytes())) .unwrap(); - match brain.read_event().expect("contiguous controller frame accepted") { + match brain + .read_event() + .expect("contiguous controller frame accepted") + { BrokerEvent::Output { seq: got, .. } => assert_eq!(got, seq), other => panic!("expected Output({seq}), got {other:?}"), } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\brain.rs:1758: // ring replays 3,4,5 from the floor; the strict cursor (re-seeded to 3 by // attach_as) ACCEPTS each contiguously — exactly-once re-fetch, no re-gap. brain - .attach_as(sid, brain.controller_resume_floor(), AttachIntent::Control, Some("node-A")) + .attach_as( + sid, + brain.controller_resume_floor(), + AttachIntent::Control, + Some("node-A"), + ) .expect("controller resume from floor"); for seq in 3u64..=5 { stub.feed Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\brain.rs:1765: .send(output_envelope(sid, seq, format!("r{seq}").as_bytes())) .unwrap(); - match brain.read_event().expect("ring-replayed floor frame accepted") { + match brain + .read_event() + .expect("ring-replayed floor frame accepted") + { BrokerEvent::Output { seq: got, .. } => assert_eq!(got, seq), other => panic!("expected re-fetched Output({seq}), got {other:?}"), } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\brain.rs:1782: // UNCHANGED across two consecutive resumes — and returns // `ControllerIrrecoverablyBehind { floor }` rather than looping forever. brain - .attach_as(sid, brain.controller_resume_floor(), AttachIntent::Control, Some("node-A")) + .attach_as( + sid, + brain.controller_resume_floor(), + AttachIntent::Control, + Some("node-A"), + ) .expect("controller second resume"); stub.feed.send(output_envelope(sid, 9, b"rolled")).unwrap(); let err = brain Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\brain.rs:1837: // ACCEPT it (the broker's Mutex-held replay cannot reorder, so a forward // jump is only ever a legitimate post-eviction ring-floor clamp). stub.feed.send(output_envelope(sid, 12, b"LIVE-A")).unwrap(); - match brain.read_event().expect("post-eviction forward jump accepted") { + match brain + .read_event() + .expect("post-eviction forward jump accepted") + { BrokerEvent::Output { seq, bytes, .. } => { - assert_eq!(seq, 12, "the forward-jumped live seq is accepted, not rejected"); + assert_eq!( + seq, 12, + "the forward-jumped live seq is accepted, not rejected" + ); assert_eq!(bytes, b"LIVE-A"); } other => panic!("expected Output(12) via snap-above, got {other:?}"), Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\brain.rs:1913: // The ring rolled between reads: the next Output frame carries a seq far // ABOVE the cursor (4504 while cursor is 100 — the legacy path would fatal // `output gap: got 4504 want 100`). Snap-above must ACCEPT it. - stub.feed.send(output_envelope(sid, 4504, b"ROLLED")).unwrap(); - match brain.read_event().expect("pre-eviction forward ring-roll gap accepted") { + stub.feed + .send(output_envelope(sid, 4504, b"ROLLED")) + .unwrap(); + match brain + .read_event() + .expect("pre-eviction forward ring-roll gap accepted") + { BrokerEvent::Output { seq, bytes, .. } => { - assert_eq!(seq, 4504, "the forward-jumped live seq is accepted, not rejected"); + assert_eq!( + seq, 4504, + "the forward-jumped live seq is accepted, not rejected" + ); assert_eq!(bytes, b"ROLLED"); } other => panic!("expected Output(4504) via snap-above, got {other:?}"), Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\brain.rs:1930: // From there it tracks contiguously and DEDUPS below the cursor: seq 4505 // accepted, the stale re-send (seq 4504, already delivered) is DEDUPED (not a // gap, not re-emitted), seq 4506 accepted. - stub.feed.send(output_envelope(sid, 4505, b"LIVE-B")).unwrap(); + stub.feed + .send(output_envelope(sid, 4505, b"LIVE-B")) + .unwrap(); stub.feed.send(output_envelope(sid, 4504, b"DUP")).unwrap(); // dedup below cursor - stub.feed.send(output_envelope(sid, 4506, b"LIVE-C")).unwrap(); + stub.feed + .send(output_envelope(sid, 4506, b"LIVE-C")) + .unwrap(); let mut accepted = Vec::new(); for _ in 0..2 { match brain.read_event().expect("subsequent live frames") { Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\brainproc.rs:423: fn record_promoted(&self, version: u64); /// Correct the record: the candidate failed readiness. Persist /// `RolledBack{…}` and fire the loud, resurfacing rollback notif. - fn record_rolled_back(&self, quarantine_version: u64, running_version: u64, rollback_binary: &str); + fn record_rolled_back( + &self, + quarantine_version: u64, + running_version: u64, + rollback_binary: &str, + ); /// The `exe_hash` the candidate stamped in `brain.ready` (the bytes it is /// actually running), or `None` if absent/garbled — degrades the promotion /// bytes-gate to readiness-only (KH 6.11, N-1-safe). Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\brainproc.rs:511: let _ = cache.record_applied(version); let _ = cache.record_last_outcome("applied"); } - fn record_rolled_back(&self, quarantine_version: u64, running_version: u64, rollback_binary: &str) { + fn record_rolled_back( + &self, + quarantine_version: u64, + running_version: u64, + rollback_binary: &str, + ) { let cache = self.cache(); let _ = cache.record_applied_state(&AppliedRecord::RolledBack { quarantine_version, Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\brainproc.rs:738: // trial, default binary" — the supervisor never panics on the record. let record = env.applied_state(); let binary: Option = match &record { - Some(AppliedRecord::RolledBack { rollback_binary, .. }) => { - Some(PathBuf::from(rollback_binary)) - } + Some(AppliedRecord::RolledBack { + rollback_binary, .. + }) => Some(PathBuf::from(rollback_binary)), _ => None, }; let is_trial = matches!(record, Some(AppliedRecord::AppliedPending { .. })); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\brainproc.rs:776: // onto the renamed old binary) fails the trial → kill + // rollback, never a falsely-`applied` record. let version = match &record { - Some(AppliedRecord::AppliedPending { version, .. }) => Some(*version), + Some(AppliedRecord::AppliedPending { version, .. }) => { + Some(*version) + } _ => None, }; if let Some(version) = version { Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\brainproc.rs:885: } reason = StartReason::Crash; backoff = next_backoff(backoff, started.elapsed(), base); - eprintln!("BRAIN_RESTART: supervised respawn in {}s", backoff.as_secs()); + eprintln!( + "BRAIN_RESTART: supervised respawn in {}s", + backoff.as_secs() + ); sleep_backoff(backoff, stop); } } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\brainproc.rs:1254: fn brain_child_args_carry_generation_and_reason() { assert_eq!( brain_child_args(7, StartReason::Update), - vec!["daemon", "brain", "--generation", "7", "--start-reason", "update"] + vec![ + "daemon", + "brain", + "--generation", + "7", + "--start-reason", + "update" + ] ); assert_eq!( brain_child_args(0, StartReason::Cold), Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\brainproc.rs:1261: - vec!["daemon", "brain", "--generation", "0", "--start-reason", "cold"] + vec![ + "daemon", + "brain", + "--generation", + "0", + "--start-reason", + "cold" + ] ); } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\brainproc.rs:1328: Some(7) ); // Staleness is visible at the primitive: gen N−1 ≠ the gen-N a gate seeks. - let stale = parse_ready_generation( - &serde_json::json!({"pid": 4321, "generation": 6}).to_string(), - ); + let stale = + parse_ready_generation(&serde_json::json!({"pid": 4321, "generation": 6}).to_string()); assert_eq!(stale, Some(6)); - assert_ne!(stale, Some(7), "a gen-6 stamp must not satisfy a gen-7 gate"); + assert_ne!( + stale, + Some(7), + "a gen-6 stamp must not satisfy a gen-7 gate" + ); // Fail-safe: legacy bare-pid text, garbage, and a stampless body → None. assert_eq!(parse_ready_generation("4321"), None, "legacy bare pid"); assert_eq!(parse_ready_generation("{ not json"), None, "garbage"); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\brainproc.rs:1351: let dir = tempfile::tempdir().unwrap(); let path = dir.path().join("brain.ready"); assert_eq!(ready_generation_at(&path), None, "absent file → not-ready"); - std::fs::write(&path, serde_json::json!({"pid": 1, "generation": 42}).to_string()) - .unwrap(); + std::fs::write( + &path, + serde_json::json!({"pid": 1, "generation": 42}).to_string(), + ) + .unwrap(); assert_eq!(ready_generation_at(&path), Some(42)); } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\brainproc.rs:1365: // Present → Some(hash). assert_eq!( parse_ready_exe_hash( - &serde_json::json!({"pid": 1, "generation": 3, "exe_hash": "deadbeef"}) - .to_string() + &serde_json::json!({"pid": 1, "generation": 3, "exe_hash": "deadbeef"}).to_string() ), Some("deadbeef".to_string()) ); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\brainproc.rs:1573: fast_child() }, ); - assert_eq!(env.promotions.lock().unwrap().as_slice(), &[7], "promoted once"); + assert_eq!( + env.promotions.lock().unwrap().as_slice(), + &[7], + "promoted once" + ); assert!(env.rollbacks.lock().unwrap().is_empty(), "no rollback"); assert_eq!(env.notifs.load(Ordering::Relaxed), 0, "no rollback notif"); - assert!(env.clears.load(Ordering::Relaxed) >= 1, "ready cleared before the trial spawn"); + assert!( + env.clears.load(Ordering::Relaxed) >= 1, + "ready cleared before the trial spawn" + ); let s = spawns.lock().unwrap(); - assert_eq!(s[0].1, StartReason::Cold, "first spawn is the cold trial candidate"); + assert_eq!( + s[0].1, + StartReason::Cold, + "first spawn is the cold trial candidate" + ); assert_eq!(s[0].2, None, "candidate spawns the default current_exe"); - assert_eq!(s[1].2, None, "a later crash respawns the SAME accepted binary, not a rollback"); + assert_eq!( + s[1].2, None, + "a later crash respawns the SAME accepted binary, not a rollback" + ); } /// (DRAINED gate — RED-first) A candidate that signals ready but whose OLD Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\brainproc.rs:1629: &[(6, 5, "/good/spt.old-6".to_string())], "the never-drained candidate is killed + rolled back (conservative, never a false-promote)" ); - assert_eq!(env.notifs.load(Ordering::Relaxed), 1, "one loud rollback notif"); + assert_eq!( + env.notifs.load(Ordering::Relaxed), + 1, + "one loud rollback notif" + ); } /// (DRAINED gate — latch releases) A ready candidate whose old generation drains Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\brainproc.rs:1712: let x = TestTrialEnv::pending(8, "/g/spt.old-8").with_hashes(Some("abc"), Some("xyz")); assert!(matches!(bytes_gate(&x, 8), BytesGate::Mismatch)); let ready_absent = TestTrialEnv::pending(8, "/g/spt.old-8").with_hashes(None, Some("abc")); - assert!(matches!(bytes_gate(&ready_absent, 8), BytesGate::Unverified)); + assert!(matches!( + bytes_gate(&ready_absent, 8), + BytesGate::Unverified + )); let staged_absent = TestTrialEnv::pending(8, "/g/spt.old-8").with_hashes(Some("abc"), None); - assert!(matches!(bytes_gate(&staged_absent, 8), BytesGate::Unverified)); + assert!(matches!( + bytes_gate(&staged_absent, 8), + BytesGate::Unverified + )); } /// (KH 6.11 — Half 2 integration) A candidate that signals ready but is Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\brainproc.rs:1759: 1, "rolled back once on the bytes mismatch" ); - assert_eq!(env.notifs.load(Ordering::Relaxed), 1, "loud rollback notif fired"); + assert_eq!( + env.notifs.load(Ordering::Relaxed), + 1, + "loud rollback notif fired" + ); } /// (KH 6.11 — Half 2 integration) A candidate ready AND running the staged Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\brainproc.rs:1825: env.as_ref(), Duration::from_secs(5), move |gen, reason, binary| { - spawns_c - .lock() - .unwrap() - .push((gen, reason, binary.map(|p| p.display().to_string()))); + spawns_c.lock().unwrap().push(( + gen, + reason, + binary.map(|p| p.display().to_string()), + )); // The candidate never signals ready and exits at once (fast_child); // once selection switches to the rollback binary, stop. if binary.is_some() { Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\brainproc.rs:1842: &[(9, 8, "/good/spt.old-9".to_string())], "rolled back exactly once, quarantine=N running=N-1" ); - assert_eq!(env.notifs.load(Ordering::Relaxed), 1, "one loud rollback notif"); + assert_eq!( + env.notifs.load(Ordering::Relaxed), + 1, + "one loud rollback notif" + ); assert!(env.promotions.lock().unwrap().is_empty(), "never promoted"); let s = spawns.lock().unwrap(); let reasons: Vec = s.iter().map(|(_, r, _)| *r).collect(); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\brainproc.rs:1849: assert_eq!( reasons, - vec![StartReason::Cold, StartReason::Crash, StartReason::Crash, StartReason::Crash], + vec![ + StartReason::Cold, + StartReason::Crash, + StartReason::Crash, + StartReason::Crash + ], "K=3 trial spawns (Cold then Crash×2) all gated, then the rollback respawn" ); assert_eq!(s[0].2, None, "trial candidate = current_exe"); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\brainproc.rs:1857: Some("/good/spt.old-9"), "after rollback, selection switches to the rollback binary" ); - assert_eq!(env.clears.load(Ordering::Relaxed), 3, "ready cleared before each of the 3 trial spawns"); + assert_eq!( + env.clears.load(Ordering::Relaxed), + 3, + "ready cleared before each of the 3 trial spawns" + ); } /// (3/A11) Alive-but-never-ready: the window elapses with the candidate alive Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\brainproc.rs:1902: &[(5, 4, "/good/spt.old-5".to_string())], "alive-never-ready rolls back" ); - assert_eq!(env.notifs.load(Ordering::Relaxed), 1, "one loud rollback notif"); + assert_eq!( + env.notifs.load(Ordering::Relaxed), + 1, + "one loud rollback notif" + ); assert!(env.promotions.lock().unwrap().is_empty(), "never promoted"); } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\brainproc.rs:2072: "a fresh broker reading a RolledBack record spawns the good binary, not current_exe" ); assert!(env.promotions.lock().unwrap().is_empty()); - assert!(env.rollbacks.lock().unwrap().is_empty(), "no NEW rollback — it is the recovery steady state"); + assert!( + env.rollbacks.lock().unwrap().is_empty(), + "no NEW rollback — it is the recovery steady state" + ); } } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\broker.rs:34: use std::collections::{HashMap, HashSet, VecDeque}; use std::io; use std::sync::atomic::{AtomicBool, AtomicU32, AtomicU64, Ordering}; -use std::sync::mpsc::{channel, sync_channel, Receiver, RecvTimeoutError, Sender, SyncSender, TrySendError}; +use std::sync::mpsc::{ + channel, sync_channel, Receiver, RecvTimeoutError, Sender, SyncSender, TrySendError, +}; use std::sync::{Arc, LazyLock, Mutex}; use std::thread::{self, JoinHandle}; use std::time::{Duration, Instant}; Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\broker.rs:51: use crate::frame::{Envelope, Role}; use crate::msg::{ applied_envelope, decode_bytes, displaced_envelope, endpoint_injected_envelope, - evicted_envelope, net_dialed_envelope, output_envelope, - size_envelope, subscribed_envelope, AdapterApplyReq, BrainRestarted, EndpointInputReq, - ErrorEvent, ExitEvent, InputReq, KillReq, NetDialReq, NetPresenceSubscribeReq, NetSent, - BrokerImageReply, StallEvictsReply, NetStatusReply, NetStreamOpenReq, NetStreamOpened, NetStreamSendReq, NetStreamSubscribeReq, - NetStreamsReply, MetMember, PairCodeSubmit, PairJoinReply, PairJoinReq, PairMeetReq, ResizeReq, SessionInfo, SessionsReply, SpawnReq, - Spawned, SubscribeOutcome, SubscribeReq, UnsubscribeReq, KIND_BRAIN_RESTART, KIND_BRAIN_RESTARTED, KIND_ENDPOINT_INPUT, KIND_ERROR, KIND_EXIT, - KIND_INPUT, KIND_KILL, KIND_NET_DIAL, KIND_NET_DIAL_LOOPBACK, KIND_NET_PRESENCE_SUBSCRIBE, - KIND_NET_SENT, - KIND_ADAPTER_APPLY, KIND_APPLIED, - KIND_BROKER_IMAGE, KIND_BROKER_IMAGE_REPLY, KIND_STALL_EVICTS, KIND_STALL_EVICTS_REPLY, - KIND_NET_STATUS, KIND_NET_STATUS_REPLY, KIND_NET_STREAMS, KIND_NET_STREAMS_REPLY, - KIND_NET_STREAM_OPEN, KIND_NET_STREAM_OPENED, KIND_NET_STREAM_SEND, KIND_NET_STREAM_SUBSCRIBE, - KIND_MET_MEMBER, KIND_PAIR_CODE_SUBMIT, KIND_PAIR_JOIN, KIND_PAIR_JOINED, KIND_PAIR_MEET, KIND_RESIZE, KIND_SESSIONS, KIND_SESSIONS_REPLY, KIND_SPAWN, - KIND_SPAWNED, KIND_SUBSCRIBE, KIND_UNSUBSCRIBE, + evicted_envelope, net_dialed_envelope, output_envelope, size_envelope, subscribed_envelope, + AdapterApplyReq, BrainRestarted, BrokerImageReply, EndpointInputReq, ErrorEvent, ExitEvent, + InputReq, KillReq, MetMember, NetDialReq, NetPresenceSubscribeReq, NetSent, NetStatusReply, + NetStreamOpenReq, NetStreamOpened, NetStreamSendReq, NetStreamSubscribeReq, NetStreamsReply, + PairCodeSubmit, PairJoinReply, PairJoinReq, PairMeetReq, ResizeReq, SessionInfo, SessionsReply, + SpawnReq, Spawned, StallEvictsReply, SubscribeOutcome, SubscribeReq, UnsubscribeReq, + KIND_ADAPTER_APPLY, KIND_APPLIED, KIND_BRAIN_RESTART, KIND_BRAIN_RESTARTED, KIND_BROKER_IMAGE, + KIND_BROKER_IMAGE_REPLY, KIND_ENDPOINT_INPUT, KIND_ERROR, KIND_EXIT, KIND_INPUT, KIND_KILL, + KIND_MET_MEMBER, KIND_NET_DIAL, KIND_NET_DIAL_LOOPBACK, KIND_NET_PRESENCE_SUBSCRIBE, + KIND_NET_SENT, KIND_NET_STATUS, KIND_NET_STATUS_REPLY, KIND_NET_STREAMS, + KIND_NET_STREAMS_REPLY, KIND_NET_STREAM_OPEN, KIND_NET_STREAM_OPENED, KIND_NET_STREAM_SEND, + KIND_NET_STREAM_SUBSCRIBE, KIND_PAIR_CODE_SUBMIT, KIND_PAIR_JOIN, KIND_PAIR_JOINED, + KIND_PAIR_MEET, KIND_RESIZE, KIND_SESSIONS, KIND_SESSIONS_REPLY, KIND_SPAWN, KIND_SPAWNED, + KIND_STALL_EVICTS, KIND_STALL_EVICTS_REPLY, KIND_SUBSCRIBE, KIND_UNSUBSCRIBE, }; use crate::nethost::{NetHost, NET_EFFECT_SESSION}; use crate::translation::{key_to_bytes, InjectFloor, KeyCmd, ToBinary, TranslationChild}; Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\broker.rs:113: } impl CtrlWriteTrace { - fn new( - conn_id: u64, - sid: u64, - epoch: u64, - seq: Option, - frame: &Envelope, - ) -> Option { + fn new(conn_id: u64, sid: u64, epoch: u64, seq: Option, frame: &Envelope) -> Option { if !rca_pty_trace_enabled() { return None; } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\broker.rs:447: /// invariant, not its exact length. fn inject_miss_strike_budget() -> u32 { match std::env::var("SPT_INJECT_MISS_STRIKE_BUDGET") { - Ok(n) => n.parse::().ok().filter(|b| *b >= 1).unwrap_or(INJECT_MISS_STRIKE_BUDGET), + Ok(n) => n + .parse::() + .ok() + .filter(|b| *b >= 1) + .unwrap_or(INJECT_MISS_STRIKE_BUDGET), Err(_) => INJECT_MISS_STRIKE_BUDGET, } } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\broker.rs:547: fn inject_text_chunk() -> usize { match std::env::var("SPT_INJECT_TEXT_CHUNK") { - Ok(n) => n.parse::().ok().filter(|c| *c > 0).unwrap_or(INJECT_TEXT_CHUNK), + Ok(n) => n + .parse::() + .ok() + .filter(|c| *c > 0) + .unwrap_or(INJECT_TEXT_CHUNK), Err(_) => INJECT_TEXT_CHUNK, } } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\broker.rs:1239: let evicted = Arc::new(AtomicBool::new(false)); let writer_evicted = Arc::clone(&evicted); let session_id = self.session_id; - let writer = - thread::spawn(move || viewer_writer(writer_send, session_id, initial, rx, writer_evicted)); + let writer = thread::spawn(move || { + viewer_writer(writer_send, session_id, initial, rx, writer_evicted) + }); self.viewers.insert( vid, ViewerSink { Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\broker.rs:3318: ); let frame = Envelope::new( KIND_SPAWNED, - serde_json::to_value(Spawned { session_id: sid, pid: spid }) - .expect("Spawned serializes"), + serde_json::to_value(Spawned { + session_id: sid, + pid: spid, + }) + .expect("Spawned serializes"), ); send_frame(send, &frame); return Ok(sid); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\broker.rs:3431: // C-1: the shared bounded-respawn give-up counter (starts at 0; the worker // resets it on a healthy commit, the dispatch respawn path increments it). let translation_respawns = Arc::new(AtomicU32::new(0)); - let translation = req - .translation_binary - .as_deref() - .and_then(|argv| { - build_translation( - argv, - &req.endpoint, - &input, - Arc::clone(&translation_respawns), - &log, - ) - }); + let translation = req.translation_binary.as_deref().and_then(|argv| { + build_translation( + argv, + &req.endpoint, + &input, + Arc::clone(&translation_respawns), + &log, + ) + }); recover(&self.sessions).insert( id, Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\broker.rs:3688: // recovered session shows clean; re-stamped if the new binary faults too). let perch = resolve_perch_path(endpoint, ParentHint::Infer); let _ = spt_store::info::set_translation_fault(&perch, None); - eprintln!("TRANSLATION_RESPAWN:{endpoint}: rebuilt faulted binary (attempt {n}/{budget})"); + eprintln!( + "TRANSLATION_RESPAWN:{endpoint}: rebuilt faulted binary (attempt {n}/{budget})" + ); } // Swap it in under the lock (the session may have exited mid-build). let mut map = recover(&self.sessions); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\broker.rs:3783: "ENDPOINT_INJECT:{} ({} bytes → translation binary{})", req.endpoint, bytes.len(), - if req.native && !idle { ", native mid-active" } else { "" } + if req.native && !idle { + ", native mid-active" + } else { + "" + } ); send_frame( send, Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\broker.rs:3808: "ENDPOINT_INJECT:{}: endpoint ACTIVE -> spool (deferred hint), not injected", req.endpoint ); - send_frame(send, &endpoint_injected_envelope(&req.endpoint, false, true)); + send_frame( + send, + &endpoint_injected_envelope(&req.endpoint, false, true), + ); } else { eprintln!( "ENDPOINT_INJECT:{}: no working translation binary (absent/faulted/worker-gone) -> SPOOLED (idle window), not injected", Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\broker.rs:3815: req.endpoint ); - send_frame(send, &endpoint_injected_envelope(&req.endpoint, false, false)); + send_frame( + send, + &endpoint_injected_envelope(&req.endpoint, false, false), + ); } Ok(()) } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\broker.rs:3821: // No hosted session for this endpoint — tell the caller to spool // NON-deferred (idle-eligible; a non-hosted target has no active window). None => { - send_frame(send, &endpoint_injected_envelope(&req.endpoint, false, false)); + send_frame( + send, + &endpoint_injected_envelope(&req.endpoint, false, false), + ); Ok(()) } } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\broker.rs:3932: }; let frame = Envelope::new( KIND_BRAIN_RESTARTED, - serde_json::to_value(BrainRestarted { honored }) - .expect("BrainRestarted serializes"), + serde_json::to_value(BrainRestarted { honored }).expect("BrainRestarted serializes"), ); send_frame(send, &frame); } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\broker.rs:4506: #[test] fn stamp_divergence_gates_writes() { // Converged already → no writes. - assert_eq!(stamp_divergence(None, false, 0, None, false, 0), (false, false)); + assert_eq!( + stamp_divergence(None, false, 0, None, false, 0), + (false, false) + ); // The stamp-before-bind loss: perch says controlled=false, session IS driven. - assert_eq!(stamp_divergence(None, false, 0, None, true, 0), (true, false)); + assert_eq!( + stamp_divergence(None, false, 0, None, true, 0), + (true, false) + ); // A remote controller's driven_by appears → control write. - assert_eq!(stamp_divergence(None, true, 0, Some("n"), true, 0), (true, false)); + assert_eq!( + stamp_divergence(None, true, 0, Some("n"), true, 0), + (true, false) + ); // Viewer count changed only → viewer write only. - assert_eq!(stamp_divergence(None, true, 0, None, true, 2), (false, true)); + assert_eq!( + stamp_divergence(None, true, 0, None, true, 2), + (false, true) + ); // Both diverge. - assert_eq!(stamp_divergence(Some("a"), false, 1, None, true, 3), (true, true)); + assert_eq!( + stamp_divergence(Some("a"), false, 1, None, true, 3), + (true, true) + ); } /// The cursor-advance kernel (restoration D4-1, doyle amendments 1–3): Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\broker.rs:4692: ); let ev: crate::msg::ViewerEvictedEvent = serde_json::from_value(env.payload).expect("marker payload"); - assert_eq!(ev.session_id, 7, "the marker names the evicted viewer's session"); + assert_eq!( + ev.session_id, 7, + "the marker names the evicted viewer's session" + ); } // ── NORMAL close: flag false → no marker; the client read hits EOF. ── Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\broker.rs:4756: ); // First append fits the depth-1 queue (no overflow, not evicted yet). - assert_eq!(log.append(b"chunk-0"), None, "no controller; first chunk fits"); + assert_eq!( + log.append(b"chunk-0"), + None, + "no controller; first chunk fits" + ); assert!( !observed.load(Ordering::Acquire), "a viewer keeping within its queue is NOT flagged" Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\broker.rs:4765: // Second append OVERFLOWS the (still-undrained) depth-1 queue → eviction: // the flag is SET (so the writer skips-to-live) and the sink is removed. - assert_eq!(log.append(b"chunk-1"), None, "no controller; eviction returns no ctrl job"); + assert_eq!( + log.append(b"chunk-1"), + None, + "no controller; eviction returns no ctrl job" + ); assert!( observed.load(Ordering::Acquire), "an overflow eviction must SET the sink's `evicted` flag BEFORE dropping \ Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\broker.rs:4836: // A VIEWER with a generous channel we CAN drain — to prove it stays fed. let (vsend, _vclient, _vrecv) = controller_socket_pair(); let (vtx, vrx) = sync_channel::(VIEWER_CHANNEL_DEPTH); - log.viewers - .insert( - 0, - ViewerSink { - tx: vtx, - send: vsend, - evicted: Arc::new(AtomicBool::new(false)), - _writer: thread::spawn(|| {}), - }, - ); + log.viewers.insert( + 0, + ViewerSink { + tx: vtx, + send: vsend, + evicted: Arc::new(AtomicBool::new(false)), + _writer: thread::spawn(|| {}), + }, + ); // Append 50 chunks. The controller channel (depth 2) fills after 2; every // further append DROPS (returns None — within the deadline, never evict) and Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\broker.rs:4890: fn contiguous_advance_freezes_on_a_gap() { let dt = AtomicU64::new(0); contiguous_advance(&dt, 0); - assert_eq!(dt.load(Ordering::Acquire), 1, "seq 0 (== cursor) advances to 1"); + assert_eq!( + dt.load(Ordering::Acquire), + 1, + "seq 0 (== cursor) advances to 1" + ); contiguous_advance(&dt, 1); - assert_eq!(dt.load(Ordering::Acquire), 2, "contiguous seq 1 advances to 2"); + assert_eq!( + dt.load(Ordering::Acquire), + 2, + "contiguous seq 1 advances to 2" + ); // GAP: cursor is 2 but seq 5 arrives (3,4 dropped while Full). FREEZE at 2 — // a high-watermark jump to 6 would skip 3,4 on resume = a B2 violation. contiguous_advance(&dt, 5); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\broker.rs:4903: ); // Re-delivering the frozen seq (2, via ring replay) resumes contiguous advance. contiguous_advance(&dt, 2); - assert_eq!(dt.load(Ordering::Acquire), 3, "re-delivering the frozen seq resumes"); + assert_eq!( + dt.load(Ordering::Acquire), + 3, + "re-delivering the frozen seq resumes" + ); // A rewind re-send (seq < cursor) is a no-op. contiguous_advance(&dt, 0); - assert_eq!(dt.load(Ordering::Acquire), 3, "a rewind re-send cannot lower the cursor"); + assert_eq!( + dt.load(Ordering::Acquire), + 3, + "a rewind re-send cannot lower the cursor" + ); } /// W1 — `advance_delivered` moves the shared cursor monotonically (D4-1) via Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\broker.rs:4984: // interleaved with single keystrokes. let inputs: Vec> = vec![ b"first".to_vec(), - b"\x03".to_vec(), // Ctrl-C + b"\x03".to_vec(), // Ctrl-C b"PASTE-BLOCK-AAAA".to_vec(), b"z".to_vec(), - b"\r".to_vec(), // Enter + b"\r".to_vec(), // Enter b"PASTE-BLOCK-BBBB".to_vec(), b"last".to_vec(), ]; Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\broker.rs:4994: for rec in &inputs { - assert!(w.enqueue(rec.clone()), "depth 256: every enqueue is accepted"); + assert!( + w.enqueue(rec.clone()), + "depth 256: every enqueue is accepted" + ); } // Close the FIFO so the drain loop terminates, then drain through the SOLE // writer exactly as `input_writer` does. Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\broker.rs:5029: // The first DEPTH enqueues fit (accepted, no backpressure yet). for i in 0..DEPTH { - assert!(w.enqueue(vec![i as u8]), "enqueue {i} fits within the bound"); + assert!( + w.enqueue(vec![i as u8]), + "enqueue {i} fits within the bound" + ); } assert!( !w.backpressure.load(Ordering::Acquire), Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\broker.rs:5049: ); // A second overflow while still saturated stays dropped + backpressured (the // stamp is rising-edge-only, but the STATE remains true — no flap to false). - assert!(!w.enqueue(b"OVERFLOW-2".to_vec()), "still dropping while full"); assert!( + !w.enqueue(b"OVERFLOW-2".to_vec()), + "still dropping while full" + ); + assert!( w.backpressure.load(Ordering::Acquire), "backpressure stays asserted while the queue remains saturated" ); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\broker.rs:5087: panic!("poison the inject floor"); }) .join(); - assert!(floor.is_poisoned(), "precondition: the floor mutex is poisoned"); + assert!( + floor.is_poisoned(), + "precondition: the floor mutex is poisoned" + ); // The fix: the recovered guard is fully usable — open() takes, is_held reads. lock_floor(&floor).open(); assert!( Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\broker.rs:5114: panic!("poison the sessions map mid-attach"); }) .join(); - assert!(sessions.is_poisoned(), "precondition: the sessions mutex is poisoned"); + assert!( + sessions.is_poisoned(), + "precondition: the sessions mutex is poisoned" + ); // The fix: the recovered guard is fully usable — the prior row survives and a // NEW attach can still insert/look up (no permanent wedge). - assert_eq!(recover(&sessions).get(&7).copied(), Some(70), "prior state survives recovery"); + assert_eq!( + recover(&sessions).get(&7).copied(), + Some(70), + "prior state survives recovery" + ); recover(&sessions).insert(9, 90); - assert_eq!(recover(&sessions).get(&9).copied(), Some(90), "the next attach still opens"); + assert_eq!( + recover(&sessions).get(&9).copied(), + Some(90), + "the next attach still opens" + ); } // [unit->REQ-HAZARD-BROKER-FLOOR-LOCK-POISON] B-1 (ii): the OutputLog RING Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\broker.rs:5142: torn.append(b"x"); // next_seq now 1, ring=[(0,x)] torn.ring.push_back((999, b"garbage".to_vec())); // back(999) >= next_seq(1) → torn let next_before = torn.next_seq; - assert!(torn.clamp_or_reset(), "a torn ring (last seq >= next_seq) is reset"); - assert!(torn.ring.is_empty(), "the torn ring is emptied — no garbage served"); - assert_eq!(torn.next_seq, next_before, "next_seq is preserved (cursors never rewind)"); + assert!( + torn.clamp_or_reset(), + "a torn ring (last seq >= next_seq) is reset" + ); + assert!( + torn.ring.is_empty(), + "the torn ring is emptied — no garbage served" + ); + assert_eq!( + torn.next_seq, next_before, + "next_seq is preserved (cursors never rewind)" + ); // Torn: over-cap ring (an interrupted prune). let mut over = OutputLog::new(3, 2, String::new(), (24, 80)); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\broker.rs:5174: .join(); assert!(log.is_poisoned(), "precondition: the log mutex is poisoned"); let g = recover_log(&log); - assert!(g.ring.is_empty(), "recover_log clamps the torn ring to empty on recovery"); - assert_eq!(g.next_seq, 1, "next_seq preserved through the poison-recover clamp"); + assert!( + g.ring.is_empty(), + "recover_log clamps the torn ring to empty on recovery" + ); + assert_eq!( + g.next_seq, 1, + "next_seq preserved through the poison-recover clamp" + ); } // [unit->REQ-TRANSLATE-COMMIT-MISS-TOLERANCE] C-1 respool-once / dead-letter: a Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\broker.rs:5192: assert_eq!(note_miss_respool(&mut set, "env-A"), MissRespool::Respool); assert!(set.contains("env-A")); // Second miss of the SAME envelope → dead-letter, NOT respooled again. - assert_eq!(note_miss_respool(&mut set, "env-A"), MissRespool::DeadLetter); + assert_eq!( + note_miss_respool(&mut set, "env-A"), + MissRespool::DeadLetter + ); // A DIFFERENT envelope respools once on its own. assert_eq!(note_miss_respool(&mut set, "env-B"), MissRespool::Respool); - assert_eq!(note_miss_respool(&mut set, "env-B"), MissRespool::DeadLetter); + assert_eq!( + note_miss_respool(&mut set, "env-B"), + MissRespool::DeadLetter + ); // A committed envelope is forgotten → a later miss respools it afresh. set.remove("env-A"); assert_eq!(note_miss_respool(&mut set, "env-A"), MissRespool::Respool); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\broker.rs:5226: let payload = b"XLATE_OK line one\nline two\nline three"; // Full echo present → verified. let full_echo = b"prompt> XLATE_OK line one\nline two\nline three\n"; - assert!(echo_verified(payload, full_echo), "a fully-echoed head verifies"); + assert!( + echo_verified(payload, full_echo), + "a fully-echoed head verifies" + ); // Head swallowed: only a suffix echoed (the field bug — mid-word start). The // leading prefix is ABSENT → verify MISS. let tail_only = b"three\r\n"; // the ~322B suffix class, head gone Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\broker.rs:5235: "a swallowed head (prefix absent from echo) fails verify — the head-loss tell" ); // A keys-only sequence types no echoable text → vacuously verified. - assert!(echo_verified(b"", b""), "empty payload is vacuously verified"); - assert!(echo_verified(b"", b"noise"), "empty payload verifies regardless of echo"); + assert!( + echo_verified(b"", b""), + "empty payload is vacuously verified" + ); + assert!( + echo_verified(b"", b"noise"), + "empty payload verifies regardless of echo" + ); // A short payload (below the prefix window) matches on its whole self. - assert!(echo_verified(b"hi", b"...hi..."), "a short payload matches whole"); - assert!(!echo_verified(b"hi", b"...ho..."), "a short payload absent → miss"); + assert!( + echo_verified(b"hi", b"...hi..."), + "a short payload matches whole" + ); + assert!( + !echo_verified(b"hi", b"...ho..."), + "a short payload absent → miss" + ); } // [unit->REQ-INJECT-MULTILINE-INTEGRITY] Layer 1 re-arm: the settle-gate must re-run Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\broker.rs:5254: fn should_settle_rearms_on_observable_pty() { // Echoing/interactive PTY (probe observed → not unobservable): re-settle EVERY // delivery's first byte — this is the class the `/clear` head-swallow bites. - assert!(should_settle(1, false), "observable PTY re-settles before each delivery"); + assert!( + should_settle(1, false), + "observable PTY re-settles before each delivery" + ); // Non-echoing ConPTY (probe unobservable, latched): skip the steady-state settle — // no reader-reattach race, and settling would burn the full deadline every time. - assert!(!should_settle(1, true), "unobservable-probe PTY skips the steady-state settle"); + assert!( + !should_settle(1, true), + "unobservable-probe PTY skips the steady-state settle" + ); // A RE-DRIVE always settles regardless of the latch (only reached on a swallowed // head → readiness must be re-confirmed before retyping). - assert!(should_settle(2, true), "a re-drive settles even when the probe is unobservable"); - assert!(should_settle(2, false), "a re-drive settles on an observable PTY too"); + assert!( + should_settle(2, true), + "a re-drive settles even when the probe is unobservable" + ); + assert!( + should_settle(2, false), + "a re-drive settles on an observable PTY too" + ); } // [unit->REQ-INJECT-MULTILINE-INTEGRITY] the subslice search the head match rides: Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\broker.rs:5272: assert!(contains_subslice(b"abcdef", b"cde")); assert!(contains_subslice(b"abcdef", b"abc")); assert!(contains_subslice(b"abcdef", b"def")); - assert!(!contains_subslice(b"abcdef", b"ce"), "non-contiguous is not a subslice"); - assert!(contains_subslice(b"abc", b""), "empty needle is vacuously present"); - assert!(!contains_subslice(b"ab", b"abc"), "needle longer than haystack is absent"); + assert!( + !contains_subslice(b"abcdef", b"ce"), + "non-contiguous is not a subslice" + ); + assert!( + contains_subslice(b"abc", b""), + "empty needle is vacuously present" + ); + assert!( + !contains_subslice(b"ab", b"abc"), + "needle longer than haystack is absent" + ); } // [unit->REQ-INJECT-MULTILINE-INTEGRITY] the output-log tap the settle-gate + Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\broker.rs:5312: // Small: whole, single emit. let mut parts: Vec> = Vec::new(); chunk_text(b"small", 256, |p| parts.push(p.to_vec())); - assert_eq!(parts, vec![b"small".to_vec()], "a small payload is one whole write"); + assert_eq!( + parts, + vec![b"small".to_vec()], + "a small payload is one whole write" + ); // Large: split into ceil(len/chunk) ordered parts, reassembling exactly. let payload: Vec = (0..1000u16).map(|i| (i % 251) as u8).collect(); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\broker.rs:5319: let chunk = 256; let mut got: Vec> = Vec::new(); chunk_text(&payload, chunk, |p| got.push(p.to_vec())); - assert_eq!(got.len(), 1000_usize.div_ceil(chunk), "ceil(len/chunk) parts"); - assert!(got.iter().take(got.len() - 1).all(|p| p.len() == chunk), "all but last are full"); + assert_eq!( + got.len(), + 1000_usize.div_ceil(chunk), + "ceil(len/chunk) parts" + ); + assert!( + got.iter().take(got.len() - 1).all(|p| p.len() == chunk), + "all but last are full" + ); let reassembled: Vec = got.concat(); - assert_eq!(reassembled, payload, "in-order reassembly is byte-identical — no head/tail loss"); + assert_eq!( + reassembled, payload, + "in-order reassembly is byte-identical — no head/tail loss" + ); } // [unit->REQ-HAZARD-INJECT-WORKER-POISON] B6 leg (ii): a PANIC inside the inject Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\broker.rs:5623: // The initial batch is ONE output frame carrying the synthesized repaint. let frame = read_frame(&mut client).expect("a repaint frame on attach"); - assert_eq!(frame.kind, crate::msg::KIND_OUTPUT, "the initial batch is an output frame"); + assert_eq!( + frame.kind, + crate::msg::KIND_OUTPUT, + "the initial batch is an output frame" + ); let ev: crate::msg::OutputEvent = serde_json::from_value(frame.payload).expect("output payload"); let repaint = decode_bytes(&ev.data_b64).expect("repaint b64 decodes"); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\broker.rs:5675: } thread::sleep(Duration::from_millis(1)); } - assert!(writer.is_finished(), "precondition: the writer thread has exited"); + assert!( + writer.is_finished(), + "precondition: the writer thread has exited" + ); log.controller = Some(ControllerSink { conn_id: 0, tx, Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\broker.rs:5690: Some("remote-node"), "precondition: a stale remote controller is present" ); - assert!(log.reap_dead_controller(), "a dead-writer controller is reaped"); + assert!( + log.reap_dead_controller(), + "a dead-writer controller is reaped" + ); assert!(!log.has_controller(), "the controller slot is cleared"); assert_eq!( log.controller_by(), Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\broker.rs:5697: None, "controller_by is now honest (None) → converge_perch_stamps clears the stamp" ); - assert!(!log.reap_dead_controller(), "idempotent: nothing left to reap"); + assert!( + !log.reap_dead_controller(), + "idempotent: nothing left to reap" + ); } // [unit->REQ-CONTROLLER-LIVENESS-REAP] B-2 no-false-reap control: a LIVE controller Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\broker.rs:5896: "a blocked-past-deadline writer is reaped though it has not exited" ); assert!(!log.has_controller(), "the controller slot is cleared"); - assert_eq!(log.controller_by(), None, "driven_by truth is now honest (None)"); + assert_eq!( + log.controller_by(), + None, + "driven_by truth is now honest (None)" + ); } /// W3a endpoint selection (REQ-ADAPTER-LIVE-UPDATE, ADR-0025): from the Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\broker.rs:5920: // sort+dedup, not just incidental ordering. let rows = vec![ // ep-b matches (sorts AFTER ep-a despite appearing first). - ("ep-b".to_string(), "claude-spt".to_string(), Some(dir_b.clone())), + ( + "ep-b".to_string(), + "claude-spt".to_string(), + Some(dir_b.clone()), + ), // ep-a, two sessions, SAME endpoint+dir → must dedup to one entry. - ("ep-a".to_string(), "claude-spt".to_string(), Some(dir_a.clone())), - ("ep-a".to_string(), "claude-spt".to_string(), Some(dir_a.clone())), + ( + "ep-a".to_string(), + "claude-spt".to_string(), + Some(dir_a.clone()), + ), + ( + "ep-a".to_string(), + "claude-spt".to_string(), + Some(dir_a.clone()), + ), // Non-matching adapter → excluded entirely. - ("ep-c".to_string(), "codex-spt".to_string(), Some(PathBuf::from("/install/ep-c"))), + ( + "ep-c".to_string(), + "codex-spt".to_string(), + Some(PathBuf::from("/install/ep-c")), + ), // Matching adapter but NO install_dir → excluded (nothing to swap). ("ep-d".to_string(), "claude-spt".to_string(), None), // PROFILE-COMPOSITE row (F015B): a `--adapter claude-spt:ccs` endpoint Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\broker.rs:5932: // stores the composite `claude-spt:ccs`, but the update carries the // PARENT record name `claude-spt` — it MUST match on the parent (an // exact-match skew is the silent-no-op bug). - ("ep-e".to_string(), "claude-spt:ccs".to_string(), Some(dir_e.clone())), + ( + "ep-e".to_string(), + "claude-spt:ccs".to_string(), + Some(dir_e.clone()), + ), ]; let got = select_endpoints_running_adapter(rows, "claude-spt"); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\crc_swap.rs:367: let plan = plan_crc_swap(s, i).unwrap(); let want_rel: PathBuf = ["sub", "dir", "x"].iter().collect(); - assert_eq!(rels(&plan), vec![want_rel.clone()], "nested changed file found"); + assert_eq!( + rels(&plan), + vec![want_rel.clone()], + "nested changed file found" + ); let only = &plan[0]; assert_eq!(only.staged, s.join(&want_rel)); assert_eq!(only.target, i.join(&want_rel)); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\crc_swap.rs:392: // fresh under a nested parent that does NOT yet exist in install → created. let fresh_rel: PathBuf = ["newdir", "fresh"].iter().collect(); write(&s.join(&fresh_rel), b"FRESH"); - assert!(!i.join("newdir").exists(), "precondition: nested parent absent"); + assert!( + !i.join("newdir").exists(), + "precondition: nested parent absent" + ); let plan = plan_crc_swap(s, i).unwrap(); assert_eq!( Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\crc_swap.rs:403: apply_crc_swap(&plan).unwrap(); - assert_eq!(fs::read(i.join("changed")).unwrap(), b"NEW", "changed got new bytes"); assert_eq!( + fs::read(i.join("changed")).unwrap(), + b"NEW", + "changed got new bytes" + ); + assert_eq!( fs::read(i.join(&fresh_rel)).unwrap(), b"FRESH", "fresh file materialized with its nested parent dir created" Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\crc_swap.rs:479: let result = apply_crc_swap_with(&plan, &rename); - assert!(result.is_err(), "the injected mid-loop commit failure propagates"); + assert!( + result.is_err(), + "the injected mid-loop commit failure propagates" + ); assert_eq!( fs::read(&first_target).unwrap(), b"BEFORE", Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\crc_swap.rs:647: write(&s.join("bin"), b"V2"); let stranded_old = i.join("bin.old"); write(&stranded_old, b"LAST-GOOD-V1"); - assert!(!i.join("bin").exists(), "precondition: target missing (crashed pre-commit)"); + assert!( + !i.join("bin").exists(), + "precondition: target missing (crashed pre-commit)" + ); let plan = plan_crc_swap(s, i).unwrap(); apply_crc_swap(&plan).unwrap(); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\crc_swap.rs:692: let plan = plan_crc_swap(s, i).unwrap(); let err = apply_crc_swap_with(&plan, &rename).expect_err("the injected displace fails"); let msg = err.to_string(); - assert!(msg.contains("crc_swap displace original"), "names the op: {msg}"); + assert!( + msg.contains("crc_swap displace original"), + "names the op: {msg}" + ); assert!(msg.contains("bin"), "carries the paths: {msg}"); - assert!(msg.contains("bin.old"), "carries the displacement target: {msg}"); - assert_eq!(err.kind(), std::io::ErrorKind::PermissionDenied, "preserves kind"); + assert!( + msg.contains("bin.old"), + "carries the displacement target: {msg}" + ); + assert_eq!( + err.kind(), + std::io::ErrorKind::PermissionDenied, + "preserves kind" + ); } } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\daemon.rs:82: // --detached BELT (REQ-HAZARD-DETACHED-DAEMON-STDIO): the respawned // unelevated daemon then runs detach_console + the null-handles guard, // so it never keeps live inherited stdio (matches every other rung). - &["daemon".to_string(), "run".to_string(), "--detached".to_string()], + &[ + "daemon".to_string(), + "run".to_string(), + "--detached".to_string(), + ], ) { Ok(Some(pid)) => { eprintln!( Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\daemon.rs:142: // marker-free rather than rendered. The `SUBNET_DETACHED:{name}` // token is the machine contract; the rest is a human hint. // [impl->REQ-CLI-OUTPUT-MARKDOWN] - eprintln!("SUBNET_DETACHED:{name} (startup default — run: spt subnet attach {name})"); + eprintln!( + "SUBNET_DETACHED:{name} (startup default — run: spt subnet attach {name})" + ); } } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\daemon.rs:182: thread::spawn(move || { let _ = serve_broker.serve(); }); - // Inbound net dispatch + outbound peer pump (D9-1) now run in - // the BRAIN child (restoration D2-1): they are pure IPC clients, - // so they live with the restartable brain and respawn with it. - // The broker keeps only the NetHost bring-up and the boot-race - // self-heal that binds it; the brain polls `net-status` and - // starts the consumers once net reports enabled. - // [impl->REQ-HAZARD-BROKER-PROCESS-ISOLATION] + // Inbound net dispatch + outbound peer pump (D9-1) now run in + // the BRAIN child (restoration D2-1): they are pure IPC clients, + // so they live with the restartable brain and respawn with it. + // The broker keeps only the NetHost bring-up and the boot-race + // self-heal that binds it; the brain polls `net-status` and + // starts the consumers once net reports enabled. + // [impl->REQ-HAZARD-BROKER-PROCESS-ISOLATION] if !net_up && node_hex.is_some() { // Boot-race self-heal (REQ-DAEMON-9): net failed to bind // but identity is sound — almost always the autostart Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\daemon.rs:397: return; } backoff = net_retry_backoff(backoff); - eprintln!("NET_BIND_RETRY: net still unavailable, retrying in {}s", backoff.as_secs()); + eprintln!( + "NET_BIND_RETRY: net still unavailable, retrying in {}s", + backoff.as_secs() + ); } } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\daemon.rs:1088: let ps_literal = wmi_cmdline.replace('\'', "''"); let script = wmi_create_script(&ps_literal); // -EncodedCommand wants base64 of the UTF-16LE script bytes. - let utf16le: Vec = script.encode_utf16().flat_map(|u| u.to_le_bytes()).collect(); + let utf16le: Vec = script + .encode_utf16() + .flat_map(|u| u.to_le_bytes()) + .collect(); let encoded = B64.encode(&utf16le); const POWERSHELL_ABS: &str = r"C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe"; Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\daemon.rs:1229: const FILE_TYPE_UNKNOWN: u32 = 0x0000; const FILE_TYPE_DISK: u32 = 0x0001; const FILE_TYPE_CHAR: u32 = 0x0002; - assert!(should_null_std_handles(FILE_TYPE_PIPE), "an undrained pipe blocks ⇒ null"); assert!( + should_null_std_handles(FILE_TYPE_PIPE), + "an undrained pipe blocks ⇒ null" + ); + assert!( !should_null_std_handles(FILE_TYPE_DISK), "a FILE redirect (2>run.log / the int-test brain-log) is disk ⇒ survives" ); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\daemon.rs:1250: #[test] fn net_retry_backoff_doubles_then_caps() { assert_eq!(net_retry_backoff(NET_RETRY_FIRST), Duration::from_secs(2)); - assert_eq!(net_retry_backoff(Duration::from_secs(2)), Duration::from_secs(4)); - assert_eq!(net_retry_backoff(Duration::from_secs(16)), Duration::from_secs(30)); - assert_eq!(net_retry_backoff(NET_RETRY_CAP), NET_RETRY_CAP, "stays capped"); + assert_eq!( + net_retry_backoff(Duration::from_secs(2)), + Duration::from_secs(4) + ); + assert_eq!( + net_retry_backoff(Duration::from_secs(16)), + Duration::from_secs(30) + ); + assert_eq!( + net_retry_backoff(NET_RETRY_CAP), + NET_RETRY_CAP, + "stays capped" + ); } // [unit->REQ-HAZARD-DETACHED-PIPE-INHERIT] the no-inherit spawn's command Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\daemon.rs:1299: #[test] fn wmi_create_script_carries_the_no_window_startup_spec() { let s = wmi_create_script("cmd.exe /c rem"); - assert!(s.contains("Win32_ProcessStartup"), "a startup spec is built"); assert!( + s.contains("Win32_ProcessStartup"), + "a startup spec is built" + ); + assert!( s.contains("ProcessStartupInformation=$si"), "the startup spec is passed to Win32_Process.Create" ); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\daemon.rs:1375: Err(io::Error::other(format!("{rung:?} failed"))) }); let e = r.expect_err("all rungs failed → Err"); - assert!(e.to_string().contains("InJob"), "the LAST rung's error: {e}"); + assert!( + e.to_string().contains("InJob"), + "the LAST rung's error: {e}" + ); assert_eq!( seen, vec![ Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\daemon.rs:1458: fn GetCurrentProcess() -> isize; fn IsProcessInJob(proc_h: isize, job_h: isize, result: *mut i32) -> i32; } - let gc = detached_no_inherit( - "ping", - &["-n".into(), "300".into(), "127.0.0.1".into()], - ) - .expect("launcher: breakaway spawn of grandchild"); + let gc = detached_no_inherit("ping", &["-n".into(), "300".into(), "127.0.0.1".into()]) + .expect("launcher: breakaway spawn of grandchild"); // Diag: is the launcher itself in a job? is the broken-away gc in ANY // job? (job_h = 0 → "any job"). Written before pidfile so the parent // sees it on read. Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\daemon.rs:1495: // KILL_ON_JOB_CLOSE so terminating the job reaps everything still in it; // BREAKAWAY_OK so a child created WITH CREATE_BREAKAWAY_FROM_JOB may escape // (the permissive shape; a job WITHOUT it would fail the spawn → fall back). - info.basic.limit_flags = - JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE | JOB_OBJECT_LIMIT_BREAKAWAY_OK; + info.basic.limit_flags = JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE | JOB_OBJECT_LIMIT_BREAKAWAY_OK; let ok = unsafe { SetInformationJobObject( job, Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\daemon.rs:1510: let launcher = Command::new(std::env::current_exe().unwrap()) // a unique substring filter selects ONLY this test in the re-run; the // env presence routes it to the launcher arm above (no recursion). - .args(["breakaway_spawn_escapes_a_kill_on_close_job", "--test-threads=1"]) + .args([ + "breakaway_spawn_escapes_a_kill_on_close_job", + "--test-threads=1", + ]) .env("SPT_BREAKAWAY_PIDFILE", &pidfile) - .env("SPT_BREAKAWAY_DIAG", std::env::temp_dir().join(format!("spt_breakaway_diag_{}.log", std::process::id()))) + .env( + "SPT_BREAKAWAY_DIAG", + std::env::temp_dir().join(format!("spt_breakaway_diag_{}.log", std::process::id())), + ) // CREATE_BREAKAWAY_FROM_JOB: escape the test-runner's OWN ancestor job // (cargo/CI run the test harness inside a job), so MY job below becomes // the launcher's ONLY job — otherwise the grandchild's breakaway lands Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\daemon.rs:1544: }; // Assign the launcher to the job BEFORE it spawns its grandchild — the // grandchild is created with breakaway, so it leaves the job at birth. - let assigned = - unsafe { AssignProcessToJobObject(job, launcher.as_raw_handle() as isize) }; + let assigned = unsafe { AssignProcessToJobObject(job, launcher.as_raw_handle() as isize) }; assert!(assigned != 0, "assign launcher to job"); // Read back the grandchild pid. Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\daemon.rs:1587: let _ = launcher.wait(); unsafe { CloseHandle(job) }; let _ = std::fs::remove_file(&pidfile); - let diagpath = std::env::temp_dir().join(format!("spt_breakaway_diag_{}.log", std::process::id())); + let diagpath = + std::env::temp_dir().join(format!("spt_breakaway_diag_{}.log", std::process::id())); let diag = std::fs::read_to_string(&diagpath).unwrap_or_default(); let _ = std::fs::remove_file(&diagpath); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\deadline.rs:348: DeadlineAnchor::open("agent-b", 100, StartReason::Crash, 5_000).unwrap(); // Re-open A in update mode → its own anchor survived B's write. let a = DeadlineAnchor::open("agent-a", 100, StartReason::Update, 9_999).unwrap(); - assert_eq!(a.anchor_ms, 1_000, "agent-a's phase must survive agent-b's write"); + assert_eq!( + a.anchor_ms, 1_000, + "agent-a's phase must survive agent-b's write" + ); assert_ne!(anchor_path("agent-a"), anchor_path("agent-b")); }); } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\deelevate.rs:783: (ok, io::Error::last_os_error()) }; let (mut ok, mut err) = call(FLAGS | CREATE_BREAKAWAY_FROM_JOB); - if ok == 0 && matches!(err.raw_os_error(), Some(ERROR_INVALID_PARAMETER) | Some(ERROR_ACCESS_DENIED)) + if ok == 0 + && matches!( + err.raw_os_error(), + Some(ERROR_INVALID_PARAMETER) | Some(ERROR_ACCESS_DENIED) + ) { eprintln!( "DEELEVATE_BREAKAWAY_DENIED: token spawn rejected CREATE_BREAKAWAY_FROM_JOB \ Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\deelevate.rs:861: fn env_overlay_keeps_explicit_spt_home_alive() { // Replace: desktop block already has SPT_HOME (the default home). let b = block(&["PATH=C:\\win", "spt_home=C:\\default"]); - let out = apply_env_overrides( - &b, - &[("SPT_HOME".to_string(), "C:\\accept".to_string())], - ); + let out = apply_env_overrides(&b, &[("SPT_HOME".to_string(), "C:\\accept".to_string())]); let got = parse(&out); assert!(got.contains(&"PATH=C:\\win".to_string())); assert!(got.contains(&"SPT_HOME=C:\\accept".to_string())); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\deelevate.rs:880: // Append: block has no SPT_HOME. let b = block(&["PATH=C:\\win"]); - let out = apply_env_overrides( - &b, - &[("SPT_HOME".to_string(), "C:\\accept".to_string())], - ); + let out = apply_env_overrides(&b, &[("SPT_HOME".to_string(), "C:\\accept".to_string())]); assert!(parse(&out).contains(&"SPT_HOME=C:\\accept".to_string())); // No overrides: block passes through unchanged. Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\digest.rs:73: /// `[digest]` declared defaults, then the consumer override on top (ADR-0019 /// presentation precedence). // [impl->REQ-TERM-5] -pub fn resolve_config(adapter_digest: Option<&ManifestDigest>, over: &DigestOverride) -> DigestConfig { +pub fn resolve_config( + adapter_digest: Option<&ManifestDigest>, + over: &DigestOverride, +) -> DigestConfig { let mut cfg = DigestConfig::default(); if let Some(d) = adapter_digest { if let Some(w) = d.window_turns { Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\digest.rs:276: // partitioned transcript (e.g. CC munges cwd into its project slug); spt-core // never munges it into a harness-specific key. if let Some(c) = cwd { - keys.entry("cwd".to_string()).or_insert_with(|| c.to_string()); + keys.entry("cwd".to_string()) + .or_insert_with(|| c.to_string()); } // [impl->REQ-INSTALL-11] the extractor binary resolves from the adapter // install dir (record `source_dir`) before PATH. Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\digest.rs:577: }; let merged = resolve_config(Some(&adapter), &over); assert_eq!(merged.window_turns, 2, "override wins"); - assert_eq!(merged.arg_truncation, 40, "unset override → adapter default"); + assert_eq!( + merged.arg_truncation, 40, + "unset override → adapter default" + ); assert!(merged.sprint_collapse, "override wins"); } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\digest.rs:600: let perch = perch::resolve_perch_path("solo", ParentHint::Infer); std::fs::create_dir_all(&perch).unwrap(); // No adapter recorded ⇒ the digest.log path. - let rec = - spt_store::info::InfoJson::new("solo", "0", std::process::id(), "sid", "live_agent"); + let rec = spt_store::info::InfoJson::new( + "solo", + "0", + std::process::id(), + "sid", + "live_agent", + ); spt_store::info::write_info(&perch, &rec).unwrap(); for line in [ r#"{"role":"input","text":"build it"}"#, Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\digest.rs:639: body: body.to_string(), ts: Some(ts.to_string()), }; - let backbone = vec![act("first", "2026-06-13T21:00:00Z"), act("third", "2026-06-13T21:00:20Z")]; + let backbone = vec![ + act("first", "2026-06-13T21:00:00Z"), + act("third", "2026-06-13T21:00:20Z"), + ]; let context = vec![ctx("msg", "2026-06-13T21:00:10Z")]; let merged = merge_by_ts(backbone, context); let order: Vec<&str> = merged Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\digest.rs:650: TimelineItem::Boundary { kind, .. } => kind.as_str(), }) .collect(); - assert_eq!(order, vec!["first", "msg", "third"], "context slots in by ts"); + assert_eq!( + order, + vec!["first", "msg", "third"], + "context slots in by ts" + ); } // Supersede test helpers: an Activity at a given generation (ordinal) + localseq, Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\digest.rs:667: } } fn sup_bound() -> TimelineItem { - TimelineItem::Boundary { kind: "clear".into(), ts: None } + TimelineItem::Boundary { + kind: "clear".into(), + ts: None, + } } fn texts(items: &[TimelineItem]) -> Vec<&str> { items Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\digest.rs:703: TimelineItem::Activity { record, seq } if record.text == "shared row" => Some(*seq), _ => None, }); - assert_eq!(seq.map(|s| s >> 32), Some(1), "survivor is B's (newest) ordinal"); + assert_eq!( + seq.map(|s| s >> 32), + Some(1), + "survivor is B's (newest) ordinal" + ); // A's row + the /clear boundary emptied ancestor → no orphaned divider. assert!( - !out.iter().any(|it| matches!(it, TimelineItem::Boundary { .. })), + !out.iter() + .any(|it| matches!(it, TimelineItem::Boundary { .. })), "the divider adjacent to the fully-superseded ancestor is trimmed: {out:?}" ); } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\digest.rs:721: sup_act("dup", "2026-06-13T21:00:00Z", 3, 1), // same gen, real repeat ]; let out = supersede_cross_generation(items); - assert_eq!(texts(&out), vec!["dup", "dup"], "same-ordinal repeats both survive"); + assert_eq!( + texts(&out), + vec!["dup", "dup"], + "same-ordinal repeats both survive" + ); } // [unit->REQ-DIGEST-GENERATION-SUPERSEDE] disjoint sessions (a genuine /clear, Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\digest.rs:735: sup_act("after clear", "2026-06-13T21:00:10Z", 1, 0), ]; let out = supersede_cross_generation(items); - assert_eq!(texts(&out), vec!["before clear", "after clear"], "both rows retained"); assert_eq!( - out.iter().filter(|it| matches!(it, TimelineItem::Boundary { .. })).count(), + texts(&out), + vec!["before clear", "after clear"], + "both rows retained" + ); + assert_eq!( + out.iter() + .filter(|it| matches!(it, TimelineItem::Boundary { .. })) + .count(), 1, "the /clear divider between two ≥1-row sessions is preserved" ); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\digest.rs:757: sup_act("C tail", "2026-06-13T21:00:09Z", 2, 1), ]; let out = supersede_cross_generation(items); - assert_eq!(texts(&out), vec!["A only", "replayed", "C tail"], "B emptied, one 'replayed' under C"); assert_eq!( - out.iter().filter(|it| matches!(it, TimelineItem::Boundary { .. })).count(), + texts(&out), + vec!["A only", "replayed", "C tail"], + "B emptied, one 'replayed' under C" + ); + assert_eq!( + out.iter() + .filter(|it| matches!(it, TimelineItem::Boundary { .. })) + .count(), 1, "exactly one divider between the two surviving sessions (A | C)" ); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\dispatch.rs:661: let reply = WanReply { outcome: outcome.token().to_string(), }; - let _ = brain.net_stream_send( - stream_id, - &reply.encode_line(), - None, - true, - ); + let _ = brain.net_stream_send(stream_id, &reply.encode_line(), None, true); replied = true; } } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\effect.rs:465: /// Whether `key`'s effect has already been applied + recorded. pub fn is_applied(&self, key: EffectKey) -> bool { - self.lock_recover() - .applied - .contains(&key) + self.lock_recover().applied.contains(&key) } /// A snapshot of the applied-set (for introspection / tests). Unordered. Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\effect.rs:474: pub fn applied_keys(&self) -> Vec { - self.lock_recover() - .applied - .iter() - .copied() - .collect() + self.lock_recover().applied.iter().copied().collect() } /// Count of distinct effects applied. Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\effect.rs:483: pub fn applied_count(&self) -> usize { - self.lock_recover() - .applied - .len() + self.lock_recover().applied.len() } /// Keys with an unfinished `PENDING` (broker crashed mid-effect). Empty on the Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\effect.rs:490: /// brain-crash path; surfaced for the future broker-restart recovery. pub fn pending_keys(&self) -> Vec { - self.lock_recover() - .pending - .iter() - .copied() - .collect() + self.lock_recover().pending.iter().copied().collect() } } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\effect.rs:895: let net_key = k(1, 2); assert_eq!( - j.apply_once(pty_key, EffectKind::PtyWrite, || Ok(())).unwrap(), + j.apply_once(pty_key, EffectKind::PtyWrite, || Ok(())) + .unwrap(), Outcome::Applied ); assert_eq!( Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\effect.rs:902: - j.apply_once(net_key, EffectKind::NetSend, || Ok(())).unwrap(), + j.apply_once(net_key, EffectKind::NetSend, || Ok(())) + .unwrap(), Outcome::Applied ); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\effect.rs:930: // PtyWrite is not. Keys are written as "sid op" tokens on the journal line. let text = std::fs::read_to_string(j.path()).expect("read journal file"); // New line shape carries the minter tag: "PENDING 1 cli 2 net-send". - let net_token = format!("{} {} {}", net_key.class, net_key.minter.as_tag(), net_key.op); - let pty_token = format!("{} {} {}", pty_key.class, pty_key.minter.as_tag(), pty_key.op); + let net_token = format!( + "{} {} {}", + net_key.class, + net_key.minter.as_tag(), + net_key.op + ); + let pty_token = format!( + "{} {} {}", + pty_key.class, + pty_key.minter.as_tag(), + pty_key.op + ); assert!( text.lines().any(|l| { - (l.starts_with("PENDING ") || l.starts_with("DONE ")) - && l.contains(&net_token) + (l.starts_with("PENDING ") || l.starts_with("DONE ")) && l.contains(&net_token) }), "the durable NetSend effect must be journaled to disk; file was: {text:?}" ); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\effect.rs:942: assert!( !text.lines().any(|l| { - (l.starts_with("PENDING ") || l.starts_with("DONE ")) - && l.contains(&pty_token) + (l.starts_with("PENDING ") || l.starts_with("DONE ")) && l.contains(&pty_token) }), "an ephemeral PtyWrite must NOT pay the durable journal write (no per-\ keystroke fsync) — REQ-HAZARD-EFFECT-JOURNAL-PTY-WEDGE. File was: {text:?}" Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\effect.rs:1068: minter: Minter::Rc, op: 3, }; - assert!(j_new.is_applied(rc_key), "new line recovers to the tagged key"); assert!( + j_new.is_applied(rc_key), + "new line recovers to the tagged key" + ); + assert!( !j_new.is_applied(legacy_key), "a new rc line is not a legacy key" ); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\effect.rs:1083: .unwrap(); let j_mixed = EffectJournal::open(&mixed_path).unwrap(); assert!(j_mixed.is_applied(legacy_key), "mixed: legacy key present"); - assert!(j_mixed.is_applied(new_producer_key), "mixed: cli key present"); + assert!( + j_mixed.is_applied(new_producer_key), + "mixed: cli key present" + ); assert_eq!( j_mixed.applied_count(), 2, Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\effect.rs:1139: op: OP, }; assert_eq!( - j.apply_once(replay, EffectKind::NetDial, || Ok(())).unwrap(), + j.apply_once(replay, EffectKind::NetDial, || Ok(())) + .unwrap(), Outcome::Deduped, "a same-minter same-op replay is still deduped" ); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\effect.rs:1169: minter: Minter::Rc, op: colliding_int, }; - assert_ne!(shell_key, rc_key, "same session+int, different minter = distinct key"); + assert_ne!( + shell_key, rc_key, + "same session+int, different minter = distinct key" + ); // Spool delivery lands first (Spool is durable — a real journal write). assert_eq!( Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\effect.rs:1176: - j.apply_once(shell_key, EffectKind::Spool, || Ok(())).unwrap(), + j.apply_once(shell_key, EffectKind::Spool, || Ok(())) + .unwrap(), Outcome::Applied, "the shell spool delivery applies" ); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\effect.rs:1180: // The rc operator's identically-numbered op must ALSO apply, not dedupe. assert_eq!( - j.apply_once(rc_key, EffectKind::PtyWrite, || Ok(())).unwrap(), + j.apply_once(rc_key, EffectKind::PtyWrite, || Ok(())) + .unwrap(), Outcome::Applied, "the rc operator op must NOT be swallowed by the shell op's key (the bug)" ); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\effect.rs:1224: assert_eq!(out, "healed"); let ops = minted.borrow(); - assert_eq!(ops.len(), 2, "run invoked exactly twice (initial + ONE retry)"); + assert_eq!( + ops.len(), + 2, + "run invoked exactly twice (initial + ONE retry)" + ); assert_eq!(ops[0].minter, Minter::Rc); assert_eq!( ops[1].minter, Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\harnesshost.rs:151: ); // [impl->REQ-HAZARD-TEMPLATE-ARGV-FILL] tokenize the template then fill each // token so a multi-word/quote/semicolon {key} value is one argv element. - let tokens = - spt_runtime::runtime::fill_template_tokens(&role.command, &keys).map_err(|e| e.to_string())?; + let tokens = spt_runtime::runtime::fill_template_tokens(&role.command, &keys) + .map_err(|e| e.to_string())?; if tokens.is_empty() { return Err("empty session command".into()); } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\harnesshost.rs:316: // A freshly minted id round-trips as provisional. assert!(is_provisional_session_id(&mint_session_id())); assert!(is_provisional_session_id("70b5bfa40901b7d4")); // the triage leak sid - // A Claude UUID is NOT provisional (dashes + length). - assert!(!is_provisional_session_id("b4421cf9-1234-5678-9abc-def012345678")); + // A Claude UUID is NOT provisional (dashes + length). + assert!(!is_provisional_session_id( + "b4421cf9-1234-5678-9abc-def012345678" + )); // Length / charset guards. assert!(!is_provisional_session_id("70b5bfa40901b7d")); // 15 chars assert!(!is_provisional_session_id("70b5bfa40901b7d40")); // 17 chars Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\harnesshost.rs:333: #[test] fn prepare_fills_id_and_session_into_self_command() { let m = harness_manifest("mock-session --id {id} --session-id {session_id}"); - let prepared = prepare_harness_spawn("doyle", "mock", "sess-abc", &m, false, None, None).unwrap(); + let prepared = + prepare_harness_spawn("doyle", "mock", "sess-abc", &m, false, None, None).unwrap(); assert_eq!( prepared.tokens, vec![ Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\harnesshost.rs:358: ) .unwrap(); let prepared = - prepare_harness_spawn("hall-a", "mock", "s", &m, false, None, Some("ENLYZEAM")).unwrap(); + prepare_harness_spawn("hall-a", "mock", "s", &m, false, None, Some("ENLYZEAM")) + .unwrap(); assert_eq!( prepared.tokens, vec![ Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\harnesshost.rs:422: .unwrap(); // Shipped + install_dir → single-element argv = absolute resolved path. - let prepared = prepare_harness_spawn("e", "cc", "s", &m, false, Some(&dir_str), None).unwrap(); + let prepared = + prepare_harness_spawn("e", "cc", "s", &m, false, Some(&dir_str), None).unwrap(); assert_eq!( prepared.translation_binary.as_deref(), Some([shipped.to_string_lossy().into_owned()].as_slice()), Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\harnesshost.rs:438: // install_dir present but file absent → bare fallback (PATH). let empty = tempfile::tempdir().unwrap(); let empty_str = empty.path().to_string_lossy().into_owned(); - let prepared = prepare_harness_spawn("e", "cc", "s", &m, false, Some(&empty_str), None).unwrap(); + let prepared = + prepare_harness_spawn("e", "cc", "s", &m, false, Some(&empty_str), None).unwrap(); assert_eq!( prepared.translation_binary.as_deref(), Some([bare.to_string()].as_slice()), Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\harnesshost.rs:459: [env.SPT_READ_ONLY]\ndirection = \"read\"\n", ) .unwrap(); - let prepared = prepare_harness_spawn("wall-b", "mock", "abc", &m, false, None, None).unwrap(); - assert_eq!(prepared.env.get("SPT_ENDPOINT_ID").map(String::as_str), Some("wall-b")); - assert_eq!(prepared.env.get("SPT_SESSION").map(String::as_str), Some("sess-abc")); + let prepared = + prepare_harness_spawn("wall-b", "mock", "abc", &m, false, None, None).unwrap(); + assert_eq!( + prepared.env.get("SPT_ENDPOINT_ID").map(String::as_str), + Some("wall-b") + ); + assert_eq!( + prepared.env.get("SPT_SESSION").map(String::as_str), + Some("sess-abc") + ); // A `read` directive injects nothing. assert!(!prepared.env.contains_key("SPT_READ_ONLY")); } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\harnesshost.rs:482: [message-idle-translation-binary]\npath = \"cc-spt-idle-translate\"\n", ) .unwrap(); - let prepared = prepare_harness_spawn("wall-a", "cc", "s", &with, false, None, None).unwrap(); + let prepared = + prepare_harness_spawn("wall-a", "cc", "s", &with, false, None, None).unwrap(); assert_eq!( prepared.translation_binary.as_deref(), Some(["cc-spt-idle-translate".to_string()].as_slice()) Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\harnesshost.rs:500: prepare_harness_spawn("wall-a", "cc", "s", &cmd, false, Some("/opt/cc"), None).unwrap(); let argv = prepared.translation_binary.expect("command argv"); assert_eq!(argv.len(), 2, "program + one arg: {argv:?}"); - assert!(argv[0].ends_with("claude-spt"), "{{adapter_dir}} filled: {argv:?}"); + assert!( + argv[0].ends_with("claude-spt"), + "{{adapter_dir}} filled: {argv:?}" + ); assert!(argv[0].contains("/opt/cc"), "into install_dir: {argv:?}"); assert_eq!(argv[1], "translate"); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\harnesshost.rs:507: // absent → None. let without = harness_manifest("claude"); - let prepared = prepare_harness_spawn("wall-a", "mock", "s", &without, false, None, None).unwrap(); + let prepared = + prepare_harness_spawn("wall-a", "mock", "s", &without, false, None, None).unwrap(); assert!(prepared.translation_binary.is_none()); } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\harnesshost.rs:522: min_spt_core_version = \"0\"\n\n[shell]\nspawn = 'sh'\n", ) .unwrap(); - assert!(prepare_harness_spawn("e", "sh", "s", &shell, false, None, None) - .unwrap_err() - .contains("not a harness")); + assert!( + prepare_harness_spawn("e", "sh", "s", &shell, false, None, None) + .unwrap_err() + .contains("not a harness") + ); // Harness with no [session.self] refused. let no_self = spt_runtime::Manifest::from_toml_str( Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\harnesshost.rs:532: min_spt_core_version = \"0\"\n", ) .unwrap(); - assert!(prepare_harness_spawn("e", "h", "s", &no_self, false, None, None) - .unwrap_err() - .contains("no [session.self]")); + assert!( + prepare_harness_spawn("e", "h", "s", &no_self, false, None, None) + .unwrap_err() + .contains("no [session.self]") + ); // Unknown {placeholder} errs naming the key. let bad = harness_manifest("mock-session --id {id} --boom {not_a_key}"); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\harnesshost.rs:541: - assert!(prepare_harness_spawn("e", "mock", "s", &bad, false, None, None) - .unwrap_err() - .contains("not_a_key")); + assert!( + prepare_harness_spawn("e", "mock", "s", &bad, false, None, None) + .unwrap_err() + .contains("not_a_key") + ); } /// A harness manifest declaring BOTH `[session.self]` and a DISTINCT Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\harnesshost.rs:569: ); // is_resume=true → the RESUME template (`--resume`), filled with the id. - let resumed = - prepare_harness_spawn("doyle", "mock", "sess-abc", &m, true, None, None).expect("resume prepares"); + let resumed = prepare_harness_spawn("doyle", "mock", "sess-abc", &m, true, None, None) + .expect("resume prepares"); assert_eq!( resumed.tokens, vec![ Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\harnesshost.rs:584: ); // is_resume=false → the SELF template (`--session-id`), same catalog. - let fresh = - prepare_harness_spawn("doyle", "mock", "sess-abc", &m, false, None, None).expect("self prepares"); + let fresh = prepare_harness_spawn("doyle", "mock", "sess-abc", &m, false, None, None) + .expect("self prepares"); assert_eq!( fresh.tokens, vec![ Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\inject.rs:109: if !is_spt_hosted_no_relay(id, owlery) { return 0; } - let perch_path = - spt_store::perch::resolve_perch_path(id, spt_store::perch::ParentHint::Infer); + let perch_path = spt_store::perch::resolve_perch_path(id, spt_store::perch::ParentHint::Infer); // Resting gate (REQ-INST-6 / KH 1.4): hold the deferred (`active_only`) rows while // the owner rests — the non-deferred set always drains on the idle window. let include_deferred = !crate::resting::deferred_held(&perch_path); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\inject.rs:139: } release_ids.extend(rest.map(|(msg_id, _, _)| msg_id)); if delivered > 0 { - eprintln!("IDLE_PARKED_DRAIN:{id}: injected {delivered} parked message(s) via translation binary"); + eprintln!( + "IDLE_PARKED_DRAIN:{id}: injected {delivered} parked message(s) via translation binary" + ); } if !release_ids.is_empty() { let _ = spt_store::spool::release_at(&perch_path, &release_ids); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\inject.rs:163: if !is_spt_hosted_no_relay(id, owlery) { return false; } - let perch_path = - spt_store::perch::resolve_perch_path(id, spt_store::perch::ParentHint::Infer); + let perch_path = spt_store::perch::resolve_perch_path(id, spt_store::perch::ParentHint::Infer); if !spt_store::perch::resolve_idle_file(id, spt_store::perch::ParentHint::Infer).exists() { return false; } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\lib.rs:147: pub mod relay; pub mod relcache; pub mod release; -pub mod rollback_compat; pub mod resthost; pub mod resting; +pub mod rollback_compat; pub mod seedmap; pub mod seedproofx; pub mod serveprobe; Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\lib.rs:192: digest_to_json, follow, pull_snapshot, render_digest, render_update, reproject, serve_digest_control, update_to_json, DigestHub, }; +pub use drivehub::{drive_clear, drive_take, drive_write, serve_drive_control, DriveHub}; pub use effect::{ with_tracing_retry, EffectJournal, EffectKey, EffectKind, Outcome, OP_NO_LONGER_HELD_MARKER, }; Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\lib.rs:198: -pub use drivehub::{ - drive_clear, drive_take, drive_write, serve_drive_control, DriveHub, -}; -pub use tunnelhub::{ - serve_tunnel_control, tunnel_clear, tunnel_ensure, tunnel_recv, tunnel_resolve, tunnel_send, - TunnelEnd, TunnelHub, -}; pub use endpoint::{ broker_socket_name, daemon_pid_path, digest_socket_name, drive_socket_name, pump_heartbeat_path, read_pump_heartbeat, seed_socket_name, tunnel_socket_name, Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\lib.rs:208: }; -pub use inject::{is_spt_hosted_no_relay, try_spt_hosted_inject}; pub use frame::{ accept_hello, Envelope, HandshakeError, Hello, Role, IPC_PROTOCOL_VERSION, MIN_COMPATIBLE_VERSION, Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\lib.rs:213: }; +pub use inject::{is_spt_hosted_no_relay, try_spt_hosted_inject}; pub use lifecycle::{BrainLifecycle, TickReport}; pub use linkhost::{ drive_channel_write, drive_shell, ensure_shell_tunnel, relink_shell, request_shell_link, Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\lib.rs:217: tunnel_owner_stream, DriveDelivery, ShellLinkError, ShellLinkRequestOutcome, }; pub use nethost::{NetConfig, NetHost, NET_EFFECT_SESSION}; -pub use serveprobe::{ - is_serving_subnet, request_subnet_probe, serve_subnet_probe, ServeProbeServeOutcome, -}; pub use notif::{ first_fire, most_recently_active_visible, produce_and_first_fire, produce_consent_notif, produce_rollback_notif, resurface_at_boundary, FirstFireOutcome, NotifSurfacePolicy, Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\lib.rs:226: - ResurfaceOutcome, NOTIF_KIND_AGENT, NOTIF_KIND_CONSENT, NOTIF_KIND_PSYCHE, - NOTIF_KIND_ROLLBACK, SUPPRESSION_WINDOW_MS, + ResurfaceOutcome, NOTIF_KIND_AGENT, NOTIF_KIND_CONSENT, NOTIF_KIND_PSYCHE, NOTIF_KIND_ROLLBACK, + SUPPRESSION_WINDOW_MS, }; pub use notifsync::{apply_notif_feed, emit_notif_feed, NotifApplyVerdict, NotifPolicy}; pub use propagate::{request_update, serve_update, UpdatePullOutcome, UpdateServeOutcome}; Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\lib.rs:233: }; pub use relay::Relay; pub use relcache::ReleaseCache; -pub use rollback_compat::PRE_READY_DURABLE_FILES; pub use release::{ current_platform, parse_verifying_key, sha256_hex, verify_artifact, verify_detached, verify_metadata, verify_signature, verify_update_set_artifact, verify_update_set_metadata, Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\lib.rs:240: - RejectReason, - ReleaseMetadata, SignedRelease, SignedUpdateSet, UpdateArtifactMetadata, UpdateSetMetadata, - UpdateSetProvenance, VerifyPolicy, + RejectReason, ReleaseMetadata, SignedRelease, SignedUpdateSet, UpdateArtifactMetadata, + UpdateSetMetadata, UpdateSetProvenance, VerifyPolicy, }; pub use resthost::{request_rest, serve_rest, RestRequestOutcome, RestServeOutcome}; pub use resting::{ Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\lib.rs:246: apply_event, arm_transition_echo, daemon_rest_event, effective_auto_suspend, fire_wake_effects, read_rest, request_freshness_pull, route_rest_event, take_freshness_pull, transition, - write_rest, EdgeReport, RestEvent, RestRecord, RestRoute, RestState, - NOT_A_HOSTED_PERCH_MARKER, PULL_MARKER_FILE, + write_rest, EdgeReport, RestEvent, RestRecord, RestRoute, RestState, NOT_A_HOSTED_PERCH_MARKER, + PULL_MARKER_FILE, }; +pub use rollback_compat::PRE_READY_DURABLE_FILES; pub use seedmap::{put_seed, take_seed, SeedRegistry}; +pub use serveprobe::{ + is_serving_subnet, request_subnet_probe, serve_subnet_probe, ServeProbeServeOutcome, +}; pub use sync::{ reconcile_after_sync, request_sync, select_refs, serve_sync, ReconcileWiring, SyncPolicy, SyncPullReport, SyncServeOutcome, Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\lib.rs:255: }; pub use transport::{DaemonTransport, LocalSocketTransport}; +pub use tunnelhub::{ + serve_tunnel_control, tunnel_clear, tunnel_ensure, tunnel_recv, tunnel_resolve, tunnel_send, + TunnelEnd, TunnelHub, +}; pub use update::{ apply_brain_only, classify, plan_update, plan_verified, plan_verified_update_set, ApplyError, BrokerAbi, ReleaseSpec, UpdateClass, UpdatePlan, BROKER_RESOURCE_ABI, Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\lifecycle.rs:331: /// never holds the read lock across the spawn/blocking call — a concurrent /// [`refresh`](Self::refresh) is never blocked by a long spawn. fn runtime_snapshot(&self) -> ManifestRuntime { - self.runtime.read().unwrap_or_else(|p| p.into_inner()).clone() + self.runtime + .read() + .unwrap_or_else(|p| p.into_inner()) + .clone() } /// A snapshot **clone** of the manifest (guard dropped on return, as above). Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\lifecycle.rs:338: fn manifest_snapshot(&self) -> Manifest { - self.manifest.read().unwrap_or_else(|p| p.into_inner()).clone() + self.manifest + .read() + .unwrap_or_else(|p| p.into_inner()) + .clone() } /// Swap BOTH the manifest and its runtime to the freshly-installed on-disk Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\lifecycle.rs:625: for raw in self.drop_dirs() { match resolve_endpoint_drop_dir(&raw, cwd_path) { Some(dir) => { - let mut got = - ingest_drops(&dir, &self.id, &project_id, now, self.cfg.protection_window_ms) - .map_err(|e| e.to_string())?; + let mut got = ingest_drops( + &dir, + &self.id, + &project_id, + now, + self.cfg.protection_window_ms, + ) + .map_err(|e| e.to_string())?; ingested.append(&mut got); } None => warn_no_cwd_once(&self.id, &raw), Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\lifecycle.rs:702: let interval_ms = self.cfg.pulse_period.as_millis() as u64; // A disk error must not stop the pulse: degrade to an in-memory anchor at // `now` (fresh-phase, unpersisted) so cadence continues regardless. - let anchor = DeadlineAnchor::open(key, interval_ms, reason, now_ms()) - .unwrap_or(DeadlineAnchor { + let anchor = + DeadlineAnchor::open(key, interval_ms, reason, now_ms()).unwrap_or(DeadlineAnchor { anchor_ms: now_ms(), interval_ms: interval_ms.max(1), }); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\lifecycle.rs:1009: // psyche lands in the DEFAULT account root → headless "Not logged in" → strike // loop (flynn's field death). Harness-agnostic: whatever was captured is // forwarded verbatim; core knows no var by name. - let parent_read_env = spt_store::info::read_info(&perch::resolve_perch_path( - &self.id, - ParentHint::Infer, - )) - .map(|r| r.read_env) - .unwrap_or_default(); + let parent_read_env = + spt_store::info::read_info(&perch::resolve_perch_path(&self.id, ParentHint::Infer)) + .map(|r| r.read_env) + .unwrap_or_default(); let runtime = self.cell.runtime_snapshot().with_spawn_env(parent_read_env); let psyche_id = format!("{}-psyche", self.id); // The psyche's OWN nested perch — where its custody sid lives (never the Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\lifecycle.rs:1055: } None => { let minted = spt_store::psyche_custody::mint_uuid_v4(); - if let Err(e) = spt_store::psyche_custody::write_psyche_sid(&psyche_perch, &minted) { + if let Err(e) = spt_store::psyche_custody::write_psyche_sid(&psyche_perch, &minted) + { // Loud but non-fatal: the turn still runs on the minted id; a next // fire re-mints (custody still None). No first-ever-mint PSYCHE_RESEED — // that marker fires ONLY at a real reseed (custody-clear on Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\lifecycle.rs:1193: Err(reason) => { *strikes += 1; let budget = psyche_turn_strike_budget(); - eprintln!("PSYCHE_TURN_FAIL:{} (strike {strikes}/{budget}): {reason}", self.id); + eprintln!( + "PSYCHE_TURN_FAIL:{} (strike {strikes}/{budget}): {reason}", + self.id + ); if psyche_turn_strikes_exhausted(*strikes, budget) { let stamp = format!("psyche per-event turn failed {strikes}x consecutively: {reason}"); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\lifecycle.rs:1589: #[test] fn psyche_turn_strikes_exhausted_boundary() { assert!(!psyche_turn_strikes_exhausted(0, 3)); - assert!(!psyche_turn_strikes_exhausted(2, 3), "under budget → tolerated"); + assert!( + !psyche_turn_strikes_exhausted(2, 3), + "under budget → tolerated" + ); assert!(psyche_turn_strikes_exhausted(3, 3), "AT budget → fault"); assert!(psyche_turn_strikes_exhausted(4, 3), "past budget → fault"); // Budget of 1 (the forced-fault int knob): the first failure is the fault. Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\lifecycle.rs:1632: host.note_turn_outcome(&mut strikes, &fail); assert_eq!(strikes, 0, "counter resets after the give-up stamp"); let s = stamp().expect("exhaustion stamps psyche_host_error"); - assert!(s.reason.contains("3x consecutively"), "stamp names the rate: {}", s.reason); + assert!( + s.reason.contains("3x consecutively"), + "stamp names the rate: {}", + s.reason + ); // A clean fire clears the stamp and keeps the counter at 0. host.note_turn_outcome(&mut strikes, &Ok(())); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\lifecycle.rs:1639: assert_eq!(strikes, 0); - assert!(stamp().is_none(), "a successful turn clears the prior fault stamp"); + assert!( + stamp().is_none(), + "a successful turn clears the prior fault stamp" + ); }); } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\lifecycle.rs:1741: !first.contains_key("psyche_context"), "the W3 {{psyche_context}} body key is REPLACED by {{psyche_context_file}}" ); - assert_eq!(first.get("id").map(String::as_str), Some("doyle"), "base keys kept"); + assert_eq!( + first.get("id").map(String::as_str), + Some("doyle"), + "base keys kept" + ); assert_eq!(first.get("node").map(String::as_str), Some("kitsubito")); // A continue turn carries the SAME path key (the discriminator is the file Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\lifecycle.rs:1748: // content, not the key) — the sid stays the psyche's own. let later = psyche_turn_keys(base(), Some("parent-sid"), "psyche-uuid", ctx); - assert_eq!(later.get("session_id").map(String::as_str), Some("psyche-uuid")); assert_eq!( + later.get("session_id").map(String::as_str), + Some("psyche-uuid") + ); + assert_eq!( later.get("psyche_context_file").map(String::as_str), Some(ctx.to_string_lossy().as_ref()) ); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\lifecycle.rs:1820: ); // FRESH with a real mind: the composed body, non-empty. - let fresh = write_psyche_context_file(&perch, first_turn_psyche_context(Some("MIND"))).unwrap(); + let fresh = + write_psyche_context_file(&perch, first_turn_psyche_context(Some("MIND"))).unwrap(); assert_eq!(std::fs::read_to_string(&fresh).unwrap(), "MIND"); assert!(std::fs::metadata(&fresh).unwrap().len() > 0); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\lifecycle.rs:1827: // FRESH with a zero-context agent: the NON-EMPTY marker (never // 0-byte — else it would masquerade as continue). Overwrite-in-place: same path. let marker = write_psyche_context_file(&perch, first_turn_psyche_context(None)).unwrap(); - assert_eq!(marker, cont, "overwrite in place — same nested-perch path each turn"); - assert_eq!(std::fs::read_to_string(&marker).unwrap(), PSYCHE_FRESH_MARKER); + assert_eq!( + marker, cont, + "overwrite in place — same nested-perch path each turn" + ); + assert_eq!( + std::fs::read_to_string(&marker).unwrap(), + PSYCHE_FRESH_MARKER + ); assert!(std::fs::metadata(&marker).unwrap().len() > 0); } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\lifecycle.rs:1904: std::fs::create_dir_all(&parent).unwrap(); write_info( &parent, - &InfoJson::new("doyle", "t", std::process::id(), "parent-sid-1", "live_agent"), + &InfoJson::new( + "doyle", + "t", + std::process::id(), + "parent-sid-1", + "live_agent", + ), ) .unwrap(); let psyche_perch = Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\lifecycle.rs:1914: assert_eq!(custody::read_psyche_sid(&psyche_perch), None); let minted = custody::mint_uuid_v4(); custody::write_psyche_sid(&psyche_perch, &minted).unwrap(); - assert_eq!(custody::read_psyche_sid(&psyche_perch).as_deref(), Some(minted.as_str())); + assert_eq!( + custody::read_psyche_sid(&psyche_perch).as_deref(), + Some(minted.as_str()) + ); // A parent /clear boundary rotates ONLY the parent perch's sid (exactly // cmd_boundary's core mutation) — the nested custody sid is untouched. Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\lifecycle.rs:1951: "/home/x/projects/spt-core" }); // Absolute passes through unchanged, cwd irrelevant. - let abs = Path::new(if cfg!(windows) { "C:/abs/drop" } else { "/abs/drop" }); - assert_eq!(resolve_endpoint_drop_dir(abs, Some(cwd)).as_deref(), Some(abs)); + let abs = Path::new(if cfg!(windows) { + "C:/abs/drop" + } else { + "/abs/drop" + }); + assert_eq!( + resolve_endpoint_drop_dir(abs, Some(cwd)).as_deref(), + Some(abs) + ); assert_eq!(resolve_endpoint_drop_dir(abs, None).as_deref(), Some(abs)); // Relative resolves UNDER the endpoint cwd (the manifest's ".claude"). assert_eq!( Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\lifecycle.rs:1973: Path::new("C:/Users/x/spt-core/owlery/hall-a/nested/hall-a-psyche"), owlery )); - assert!(is_owlery_internal(Path::new("c:\\users\\x\\spt-core\\owlery\\doyle"), owlery)); - assert!(!is_owlery_internal(Path::new("C:/Users/x/Documents/projects/spt-core"), owlery)); - assert!(!is_owlery_internal(Path::new("C:/Users/x/spt-core/owleryXYZ"), owlery)); + assert!(is_owlery_internal( + Path::new("c:\\users\\x\\spt-core\\owlery\\doyle"), + owlery + )); + assert!(!is_owlery_internal( + Path::new("C:/Users/x/Documents/projects/spt-core"), + owlery + )); + assert!(!is_owlery_internal( + Path::new("C:/Users/x/spt-core/owleryXYZ"), + owlery + )); } // [int->REQ-STORE-CONTEXT-BRANCH-FILL] use-it-like-a-human: a REAL pulse tick with Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\lifecycle.rs:2141: #[cfg(windows)] let command = { let script = home.join("mark.bat"); - std::fs::write(&script, format!("@echo ran>\"{}\"\r\n", marker.display())) - .unwrap(); + std::fs::write(&script, format!("@echo ran>\"{}\"\r\n", marker.display())).unwrap(); format!("cmd /C \"{}\"", script.display()) }; #[cfg(unix)] Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\lifecycle.rs:2149: let command = { let script = home.join("mark.sh"); - std::fs::write(&script, format!("echo ran > \"{}\"\n", marker.display())) - .unwrap(); + std::fs::write(&script, format!("echo ran > \"{}\"\n", marker.display())).unwrap(); format!("sh {}", script.display()) }; let toml = format!( Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\lifecycle.rs:2354: }; let anchor_of = || { let raw = std::fs::read_to_string(crate::deadline::anchor_path("pulse")).unwrap(); - serde_json::from_str::(&raw).unwrap().anchor_ms + serde_json::from_str::(&raw) + .unwrap() + .anchor_ms }; run(StartReason::Cold); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\lifecycle.rs:2362: // Update keeps the same grid phase (no re-base) even across a restart. run(StartReason::Update); - assert_eq!(anchor_of(), cold_phase, "Update must preserve the grid phase"); + assert_eq!( + anchor_of(), + cold_phase, + "Update must preserve the grid phase" + ); // A crash restart re-bases the anchor to a fresh instant. std::thread::sleep(Duration::from_millis(5)); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\lifecycle.rs:2847: "2", "after a transient garbage write, the next valid publish still reloads" ); - assert_eq!(last, host.manifest_disk_hash(), "and `last` finally advances"); + assert_eq!( + last, + host.manifest_disk_hash(), + "and `last` finally advances" + ); }); } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\lifecycle.rs:2871: let mut last: Option = None; host.reload_manifest_if_changed(&mut last); - assert_eq!(last, None, "no install dir ⇒ `last` stays None (clean no-op)"); + assert_eq!( + last, None, + "no install dir ⇒ `last` stays None (clean no-op)" + ); assert_eq!( host.cell.manifest_snapshot().adapter.version, "1", Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\linkhost.rs:146: // `always` prompts unconditionally with allow-always suppressed. let persist_allowed = cap.require_approval == ShellApproval::Remembered; if persist_allowed { - if let GrantDecision::Allowed = - grants::decide(store, &capability, owner, node, qualifier.as_deref(), target) - { + if let GrantDecision::Allowed = grants::decide( + store, + &capability, + owner, + node, + qualifier.as_deref(), + target, + ) { return None; } } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\linkhost.rs:837: // gateway-A spawns + owns the shell. let id = shellinfo::spawn_record(&owlery, "playdate-gw-a", "Trivial", Some("Scout")) .expect("mint"); - let (out, _) = - run_action(&owlery, "playdate-gw-a", "Scout", SHELL_LINK_RELINK, &[], "op1"); - assert!(matches!(out, ShellLinkServeOutcome::Ok(_)), "relink: {out:?}"); + let (out, _) = run_action( + &owlery, + "playdate-gw-a", + "Scout", + SHELL_LINK_RELINK, + &[], + "op1", + ); + assert!( + matches!(out, ShellLinkServeOutcome::Ok(_)), + "relink: {out:?}" + ); // resolve_link_target — the shared front half of cmd/drive/tunnel/ // relink — resolves the gateway owner's shell opaquely (no type gate). Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\linkhost.rs:849: // ...and drives a command through identically to an agent owner. let args = vec!["note".to_string(), "hi".to_string()]; - let (out, _) = - run_action(&owlery, "playdate-gw-a", "Scout", SHELL_LINK_CMD, &args, "op2"); - assert!(matches!(out, ShellLinkServeOutcome::Ok(_)), "gateway cmd: {out:?}"); + let (out, _) = run_action( + &owlery, + "playdate-gw-a", + "Scout", + SHELL_LINK_CMD, + &args, + "op2", + ); + assert!( + matches!(out, ShellLinkServeOutcome::Ok(_)), + "gateway cmd: {out:?}" + ); // Exclusivity keys on the owner ENDPOINT-ID, not the type: gateway-B // (same type="gateway", different id) resolves NOTHING for the same Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\linkhost.rs:863: ), "a same-type different-id owner resolves no shell (id-scoped, not type-scoped)" ); - let (out, reply) = - run_action(&owlery, "playdate-gw-b", "Scout", SHELL_LINK_CMD, &args, "op3"); + let (out, reply) = run_action( + &owlery, + "playdate-gw-b", + "Scout", + SHELL_LINK_CMD, + &args, + "op3", + ); assert!(matches!(out, ShellLinkServeOutcome::Failed(_)), "{out:?}"); assert!( matches!(reply, ShellLinkRecord::Reply { outcome, .. } if outcome == "no_shell"), Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\linkhost.rs:880: let spawn = "cmd /C exit 0"; #[cfg(unix)] let spawn = "true"; - let p = if persistent { "persistent = true\n" } else { "" }; + let p = if persistent { + "persistent = true\n" + } else { + "" + }; let src = perch::spt_home().join("srcs").join(name); std::fs::create_dir_all(&src).unwrap(); std::fs::write( Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\linkhost.rs:915: other => panic!("offline must drop, got {other:?}"), } assert!( - spt_store::spool::peek_all_at(&perch_path).unwrap().is_empty(), + spt_store::spool::peek_all_at(&perch_path) + .unwrap() + .is_empty(), "an offline drive drop never spools" ); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\linkhost.rs:926: info.status = SHELL_STATUS_ONLINE.to_string(); shellinfo::write_shell_info(&perch_path, &info).unwrap(); match prepare_drive(&owlery, "doyle", "Stick", "stick", "x=0.7,y=-0.2").unwrap() { - DrivePrep::Deliver { id: d, token, frame } => { + DrivePrep::Deliver { + id: d, + token, + frame, + } => { assert_eq!(d, id); assert!(!token.is_empty(), "the parked link token is the stamp"); assert!( Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\linkhost.rs:933: - frame.starts_with(""), + frame.starts_with( + "" + ), "{frame}" ); assert!(frame.contains("x=0.7,y=-0.2")); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\linkhost.rs:973: ); let args = vec!["stick".to_string(), "x=0.5".to_string()]; - let (out, reply) = run_action(&owlery, "doyle", "Stick", SHELL_LINK_DRIVE, &args, "op1"); + let (out, reply) = + run_action(&owlery, "doyle", "Stick", SHELL_LINK_DRIVE, &args, "op1"); let ShellLinkServeOutcome::Ok(detail) = &out else { panic!("offline drive is a defined drop (ok), got {out:?}") }; Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\linkhost.rs:980: - assert!(detail.contains("dropped") && detail.contains("offline"), "{detail}"); + assert!( + detail.contains("dropped") && detail.contains("offline"), + "{detail}" + ); assert!(matches!(reply, ShellLinkRecord::Reply { outcome, .. } if outcome == "ok")); // D1: NOT woken — no relink fired, so still no token parked. assert!( Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\linkhost.rs:986: ); // D3: never spooled. assert!( - spt_store::spool::peek_all_at(&perch_path).unwrap().is_empty(), + spt_store::spool::peek_all_at(&perch_path) + .unwrap() + .is_empty(), "the remote drive path makes zero spool call" ); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\linkhost.rs:994: let (out, reply) = run_action(&owlery, "mallory", "Stick", SHELL_LINK_DRIVE, &args, "op2"); assert!(matches!(out, ShellLinkServeOutcome::Failed(_)), "{out:?}"); - assert!(matches!(reply, ShellLinkRecord::Reply { outcome, .. } if outcome == "no_shell")); + assert!( + matches!(reply, ShellLinkRecord::Reply { outcome, .. } if outcome == "no_shell") + ); // A drive request with no args is a bad request (needs type+payload). let (out, _) = run_action(&owlery, "doyle", "Stick", SHELL_LINK_DRIVE, &[], "op3"); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\linkhost.rs:1001: - assert!(matches!(out, ShellLinkServeOutcome::BadRequest(_)), "{out:?}"); + assert!( + matches!(out, ShellLinkServeOutcome::BadRequest(_)), + "{out:?}" + ); }); } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\linkhost.rs:1030: let node = "nodehex"; // Ungated `list` → proceed. - assert!(act_gate_decide(&GrantStore::default(), &shell, "list", "gw", node, None).is_none()); + assert!( + act_gate_decide(&GrantStore::default(), &shell, "list", "gw", node, None).is_none() + ); // `remembered` `attach`, no grant → blocked, ask names the scope, and // allow-always may persist (remembered). Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\livehost.rs:206: let Some(adapter) = info.adapter.as_deref() else { continue; // adapterless endpoint — never live-capable }; - let manifest = match spt_runtime::registry::resolve_option_in(registered, adapters_dir, adapter) - { - Ok(m) => m, - Err(_) => { - // FOLD-IN (A-2, REQ-WAKE-RESUME-LEG): a deregistered adapter on an - // online endpoint was silently skipped — the SAME silent host-failure - // class the resume leg fixes. Stamp the loud host_error REPORT (never - // status — the field is a report, not a liveness input). - // [impl->REQ-WAKE-RESUME-LEG] - let _ = spt_store::info::set_host_error( - &perch, - Some(&format!( - "adapter '{adapter}' is not a registered/active adapter on this \ + let manifest = + match spt_runtime::registry::resolve_option_in(registered, adapters_dir, adapter) { + Ok(m) => m, + Err(_) => { + // FOLD-IN (A-2, REQ-WAKE-RESUME-LEG): a deregistered adapter on an + // online endpoint was silently skipped — the SAME silent host-failure + // class the resume leg fixes. Stamp the loud host_error REPORT (never + // status — the field is a report, not a liveness input). + // [impl->REQ-WAKE-RESUME-LEG] + let _ = spt_store::info::set_host_error( + &perch, + Some(&format!( + "adapter '{adapter}' is not a registered/active adapter on this \ node — register it (spt adapter add)" - )), - ); - continue; - } - }; + )), + ); + continue; + } + }; // [impl->REQ-INSTALL-11] resolve the Psyche role program against the // adapter install dir — the registry record's precise `source_dir`, the // same dir Feature E's api seam uses (mod.rs::resolve_ctx_manifest). The Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\livehost.rs:372: } let pid_alive = read_resume_pid(perch).is_some_and(spt_store::proc::is_process_alive); // The newest ledger row carries the session to resume + its recorded adapter (D-2). - let last = spt_store::sessions::last_k(perch, 1).into_iter().next_back(); + let last = spt_store::sessions::last_k(perch, 1) + .into_iter() + .next_back(); let last_sid = last.as_ref().map(|e| e.session_id.as_str()); let recorded_adapter = last .as_ref() Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\livehost.rs:381: let registered_ok = recorded_adapter.is_some_and(|a| { spt_runtime::registry::resolve_option_in(registered, adapters_dir, a).is_ok() }); - match decide_resume(rest_state, pid_alive, last_sid, recorded_adapter, registered_ok) { + match decide_resume( + rest_state, + pid_alive, + last_sid, + recorded_adapter, + registered_ok, + ) { ResumeAction::Skip | ResumeAction::StandDown => {} ResumeAction::NoResumeMaterial => { eprintln!( Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\livehost.rs:434: reason_tag: &str, ) { let parent = adapter.split(':').next().unwrap_or(adapter); - let manifest = match spt_runtime::registry::resolve_option_in(registered, adapters_dir, adapter) { + let manifest = match spt_runtime::registry::resolve_option_in(registered, adapters_dir, adapter) + { Ok(m) => m, Err(_) => return, // adapter not registered/active — the caller gated on this }; Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\livehost.rs:473: Err(e) => { let _ = spt_store::info::set_host_error( perch, - Some(&format!("{reason_tag}-resume could not launch the harness: {e}")), + Some(&format!( + "{reason_tag}-resume could not launch the harness: {e}" + )), ); eprintln!("{reason_tag}_RESUME_FAIL:{id}: {e}"); } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\livehost.rs:582: } RestartResume::Resume => { // Resume material from the newest ledger row (session + adapter + cwd). - let Some(last) = spt_store::sessions::last_k(&perch, 1).into_iter().next_back() + let Some(last) = spt_store::sessions::last_k(&perch, 1) + .into_iter() + .next_back() else { eprintln!( "DAEMON_RESTART_RESUME_SKIP:{id}: online spt-hosted but no ledger \ Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\livehost.rs:591: continue; }; let Some(adapter) = last.adapter.as_deref().or(info.adapter.as_deref()) else { - eprintln!("DAEMON_RESTART_RESUME_SKIP:{id}: no adapter recorded to resume under"); + eprintln!( + "DAEMON_RESTART_RESUME_SKIP:{id}: no adapter recorded to resume under" + ); continue; }; launch_ledger_resume( Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\livehost.rs:638: lifecycle.run_pulse_loop(Some(&session_id), &stop, reason, |_report| {}); }) }; - set.insert(id, HostedLife { stop, thread: handle }); + set.insert( + id, + HostedLife { + stop, + thread: handle, + }, + ); } /// B2 KEYSTONE — PULL liveness reconcile (REQ-HAZARD-HOSTED-LIVENESS-RECONCILE): Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\livehost.rs:885: // Pin 3 residue: clear the stale ready registration the wrapper wrote (info.json + // `ready` marker) so no dead-pid phantom ready perch is left behind. let _ = std::fs::remove_file(psyche_perch.join("info.json")); - let _ = std::fs::remove_file(perch::resolve_ready_file(&psyche_id, ParentHint::Explicit(id))); + let _ = std::fs::remove_file(perch::resolve_ready_file( + &psyche_id, + ParentHint::Explicit(id), + )); eprintln!( "LEGACY_PSYCHE_SWEEP_REAP:{id} pid={pid}: reaped stranded pre-W3 resident psyche \ + cleared its stale `{psyche_id}` ready registration" Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\livehost.rs:1072: fn seed_live_perch(id: &str, adapter: &str, status: &str) { let perch = perch::resolve_perch_path(id, ParentHint::Infer); std::fs::create_dir_all(&perch).unwrap(); - let mut rec = spt_store::info::InfoJson::new(id, "t", std::process::id(), "sid-1", "live_agent"); + let mut rec = + spt_store::info::InfoJson::new(id, "t", std::process::id(), "sid-1", "live_agent"); rec.adapter = Some(adapter.to_string()); spt_store::info::write_info(&perch, &rec).unwrap(); spt_store::info::set_status(&perch, status).unwrap(); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\livehost.rs:1165: Some(spt_store::liveness::STATUS_OFFLINE), "dead harness (no session) → offline" ); - assert_eq!(status("alive").as_deref(), Some(STATUS_ONLINE), "session present → stays"); - assert_eq!(status("relay").as_deref(), Some(STATUS_ONLINE), "relay exempt"); - assert_eq!(status("legacy").as_deref(), Some(STATUS_ONLINE), "legacy None exempt"); - assert_eq!(status("ready").as_deref(), Some(STATUS_ONLINE), "ready_agent ignored"); + assert_eq!( + status("alive").as_deref(), + Some(STATUS_ONLINE), + "session present → stays" + ); + assert_eq!( + status("relay").as_deref(), + Some(STATUS_ONLINE), + "relay exempt" + ); + assert_eq!( + status("legacy").as_deref(), + Some(STATUS_ONLINE), + "legacy None exempt" + ); + assert_eq!( + status("ready").as_deref(), + Some(STATUS_ONLINE), + "ready_agent ignored" + ); // [unit->REQ-HAZARD-DRIVEN-BY-SELFHEAL] Gap B: the reconcile clears the // stale driven_by latch on the offlined sessionless perch, but must NOT Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\livehost.rs:1208: .map(|i| i.controlled) .unwrap_or(false) }; - assert!(!controlled("dead"), "B3: sessionless perch → controlled CLEARED"); + assert!( + !controlled("dead"), + "B3: sessionless perch → controlled CLEARED" + ); assert!(controlled("alive"), "live session → controlled untouched"); - assert!(controlled("relay"), "exempt relay (Some(false)) → controlled untouched"); + assert!( + controlled("relay"), + "exempt relay (Some(false)) → controlled untouched" + ); }); } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\livehost.rs:1226: with_home(|_| { let perch = perch::resolve_perch_path("hallb", ParentHint::Infer); std::fs::create_dir_all(&perch).unwrap(); - let mut rec = - spt_store::info::InfoJson::new("hallb", "t", std::process::id(), "sid", "live_agent"); + let mut rec = spt_store::info::InfoJson::new( + "hallb", + "t", + std::process::id(), + "sid", + "live_agent", + ); rec.controllable = Some(true); spt_store::info::write_info(&perch, &rec).unwrap(); // Already OFFLINE (the dead endpoint), yet still stamped controlled + Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\livehost.rs:1244: ); let after = spt_store::info::read_info(&perch).unwrap(); - assert!(!after.controlled, "sticky controlled reaped on the already-offline dead perch"); + assert!( + !after.controlled, + "sticky controlled reaped on the already-offline dead perch" + ); assert_eq!(after.driven_by, None, "sticky driven_by reaped too"); assert_eq!( after.status.as_deref(), Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\livehost.rs:1273: let seed_ctrl = |id: &str| { let perch = perch::resolve_perch_path(id, ParentHint::Infer); std::fs::create_dir_all(&perch).unwrap(); - let mut rec = - spt_store::info::InfoJson::new(id, "t", std::process::id(), "sid-1", "live_agent"); + let mut rec = spt_store::info::InfoJson::new( + id, + "t", + std::process::id(), + "sid-1", + "live_agent", + ); rec.adapter = Some("mock".to_string()); rec.controllable = Some(true); spt_store::info::write_info(&perch, &rec).unwrap(); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\livehost.rs:1311: "sessionless controllable perch is offlined at boot, not hosted" ); // The live, session-backed perch stays online and IS hosted. - assert_eq!(status("livee").as_deref(), Some(STATUS_ONLINE), "session-backed stays online"); - assert_eq!(set.len(), 1, "only the session-backed endpoint is hosted (no phantom revival)"); + assert_eq!( + status("livee").as_deref(), + Some(STATUS_ONLINE), + "session-backed stays online" + ); + assert_eq!( + set.len(), + 1, + "only the session-backed endpoint is hosted (no phantom revival)" + ); set.stop_host("livee"); // teardown the driver thread }); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\livehost.rs:1347: std::fs::create_dir_all(&lp).unwrap(); spt_store::info::write_info( &lp, - &spt_store::info::InfoJson::new("liveparent", "0", std::process::id(), "sid", "live_agent"), + &spt_store::info::InfoJson::new( + "liveparent", + "0", + std::process::id(), + "sid", + "live_agent", + ), ) .unwrap(); spt_store::info::set_status(&lp, STATUS_ONLINE).unwrap(); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\livehost.rs:1403: let perch = perch::resolve_perch_path(id, ParentHint::Infer); std::fs::create_dir_all(&perch).unwrap(); // controllable NOT set (bind has not run yet — this is the skeleton). - let rec = spt_store::info::InfoJson::new( - id, "t", std::process::id(), "", "live_agent", - ); + let rec = + spt_store::info::InfoJson::new(id, "t", std::process::id(), "", "live_agent"); spt_store::info::write_info(&perch, &rec).unwrap(); spt_store::info::set_status(&perch, STATUS_UNBOUND).unwrap(); }; Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\livehost.rs:1452: // The spt-hosted perch on disk (online-latched, controllable). let perch = perch::resolve_perch_path("wallb", ParentHint::Infer); std::fs::create_dir_all(&perch).unwrap(); - let mut rec = - spt_store::info::InfoJson::new("wallb", "t", std::process::id(), "sid", "live_agent"); + let mut rec = spt_store::info::InfoJson::new( + "wallb", + "t", + std::process::id(), + "sid", + "live_agent", + ); rec.controllable = Some(true); spt_store::info::write_info(&perch, &rec).unwrap(); spt_store::info::set_status(&perch, STATUS_ONLINE).unwrap(); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\livehost.rs:1519: // Kill the session; wait for the exit-waiter to reap it from the table. brain.kill_session().unwrap(); assert!( - wait_until(Duration::from_secs(5), || !session_set(&mut brain).contains("wallb")), + wait_until(Duration::from_secs(5), || !session_set(&mut brain) + .contains("wallb")), "killed session leaves the broker table" ); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\livehost.rs:1526: // Now the pull reconcile clears the latch → offline. let live2 = session_set(&mut brain); let offlined = reconcile_hosted_liveness(&perch::owlery_dir(), &live2); - assert_eq!(offlined, vec!["wallb".to_string()], "dead-session perch offlined"); assert_eq!( + offlined, + vec!["wallb".to_string()], + "dead-session perch offlined" + ); + assert_eq!( status("wallb").as_deref(), Some(spt_store::liveness::STATUS_OFFLINE), "the status=online latch is cleared once the broker session is gone" Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\livehost.rs:1663: &cfg, StartReason::Crash, ); - assert_eq!(second.len(), 1, "a fresh brain re-hosts the online endpoint"); + assert_eq!( + second.len(), + 1, + "a fresh brain re-hosts the online endpoint" + ); set_then_teardown(&second); }); } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\livehost.rs:1764: } std::thread::sleep(std::time::Duration::from_millis(20)); } - assert!(removed, "could not remove the perch dir for the torn-down case"); + assert!( + removed, + "could not remove the perch dir for the torn-down case" + ); run(); assert!(set.is_empty(), "a gone perch dir un-hosts the driver"); }); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\livehost.rs:1825: let _ = sibling.kill(); let _ = sibling.wait(); - assert!(real, "the real {{id}} legacy wrapper (basename + cmdline match) is reapable"); assert!( + real, + "the real {{id}} legacy wrapper (basename + cmdline match) is reapable" + ); + assert!( spared, "a same-basename sibling with a DIFFERENT id is SPARED — no wrong-kill on a shared box" ); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\livehost.rs:1856: seed(".live-bin"); seed(".live-bin.old-0"); gc_live_bin_dirs(owlery.path()); - assert!(!perch.join(".live-bin").exists(), "the stranded .live-bin own-copy is GC'd at brain start"); - assert!(!perch.join(".live-bin.old-0").exists(), "prior displaced .live-bin.old litter is swept too"); - assert!(perch.join("info.json").is_file(), "the perch + its info.json are untouched"); + assert!( + !perch.join(".live-bin").exists(), + "the stranded .live-bin own-copy is GC'd at brain start" + ); + assert!( + !perch.join(".live-bin.old-0").exists(), + "prior displaced .live-bin.old litter is swept too" + ); + assert!( + perch.join("info.json").is_file(), + "the perch + its info.json are untouched" + ); // ── Image-locked path: an injected remove that ALWAYS fails → the `.live-bin` is // DISPLACED to a fresh `.live-bin.old*` sibling (not deleted, not errored). ── Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\livehost.rs:1865: seed(".live-bin"); gc_live_bin_dirs_with(owlery.path(), &|_| { - Err(std::io::Error::new(std::io::ErrorKind::PermissionDenied, "locked")) + Err(std::io::Error::new( + std::io::ErrorKind::PermissionDenied, + "locked", + )) }); assert!( !perch.join(".live-bin").exists(), Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\livehost.rs:1875: .flatten() .filter(|e| e.file_name().to_string_lossy().starts_with(".live-bin.old")) .collect(); - assert_eq!(displaced.len(), 1, "the locked own-copy is renamed to exactly one fresh .live-bin.old*"); + assert_eq!( + displaced.len(), + 1, + "the locked own-copy is renamed to exactly one fresh .live-bin.old*" + ); // fresh_live_bin_old never renames OVER a still-mapped prior `.old`. let fresh = fresh_live_bin_old(&perch.join(".live-bin")); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\livehost.rs:1943: ); // Woken + registered → Resume{sid,adapter}. assert_eq!( - decide_resume(Some(RestState::Active), false, Some("sid9"), Some("mock"), true), + decide_resume( + Some(RestState::Active), + false, + Some("sid9"), + Some("mock"), + true + ), ResumeAction::Resume { session_id: "sid9".into(), adapter: "mock".into() Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\livehost.rs:1950: } ); // Woken + UNREGISTERED recorded adapter → Refuse naming it + the next action. - match decide_resume(Some(RestState::Active), false, Some("sid9"), Some("ghost"), false) { + match decide_resume( + Some(RestState::Active), + false, + Some("sid9"), + Some("ghost"), + false, + ) { ResumeAction::Refuse(msg) => assert!( msg.contains("ghost") && msg.contains("spt adapter add"), "F-1 refuse names the adapter + next action: {msg}" Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\livehost.rs:1984: "F-1 host_error: {err}" ); assert!(info.status.is_none(), "the resume leg NEVER stamps status"); - assert!(!perch.join(RESUME_PID_FILE).exists(), "refused → no spawn → no resume pid"); + assert!( + !perch.join(RESUME_PID_FILE).exists(), + "refused → no spawn → no resume pid" + ); assert_eq!(set.len(), 0, "nothing hosted"); }); } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\livehost.rs:1996: with_home(|_| { let perch = perch::resolve_perch_path("cold", ParentHint::Infer); std::fs::create_dir_all(&perch).unwrap(); - let mut rec = - spt_store::info::InfoJson::new("cold", "t", std::process::id(), "sid", "live_agent"); + let mut rec = spt_store::info::InfoJson::new( + "cold", + "t", + std::process::id(), + "sid", + "live_agent", + ); rec.adapter = Some("mock".into()); spt_store::info::write_info(&perch, &rec).unwrap(); crate::resting::write_rest(&perch, RestState::Active, 0).unwrap(); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\livehost.rs:2012: StartReason::Cold, ); let info = spt_store::info::read_info(&perch).unwrap(); - assert!(info.host_error.is_none(), "no material → benign, not an error"); + assert!( + info.host_error.is_none(), + "no material → benign, not an error" + ); assert!(!perch.join(RESUME_PID_FILE).exists(), "no spawn"); assert_eq!(set.len(), 0); }); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\livehost.rs:2036: StartReason::Cold, ); let info = spt_store::info::read_info(&perch).unwrap(); - assert!(info.host_error.is_none(), "not woken → no attempt, no error"); + assert!( + info.host_error.is_none(), + "not woken → no attempt, no error" + ); assert!(!perch.join(RESUME_PID_FILE).exists(), "no spawn"); }); } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\livehost.rs:2084: fn restart_resume_gate_only_reruns_the_orphaned_spt_hosted_dead_set() { // The fully-qualifying base case → Resume. assert_eq!( - restart_resume_gate(LIVE_AGENT_STATE, Some(STATUS_ONLINE), Some(true), false, false, false), + restart_resume_gate( + LIVE_AGENT_STATE, + Some(STATUS_ONLINE), + Some(true), + false, + false, + false + ), RestartResume::Resume, "online + spt-hosted + orphaned + no-relay + dead custody → re-run" ); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\livehost.rs:2091: // Not a live agent → Skip. assert_eq!( - restart_resume_gate("ready_agent", Some(STATUS_ONLINE), Some(true), false, false, false), + restart_resume_gate( + "ready_agent", + Some(STATUS_ONLINE), + Some(true), + false, + false, + false + ), RestartResume::Skip, "a non-live-agent state is not re-run" ); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\livehost.rs:2097: // Wasn't online at restart (signed off / already offline) → Skip (never resurrect). assert_eq!( - restart_resume_gate(LIVE_AGENT_STATE, Some(STATUS_UNBOUND), Some(true), false, false, false), + restart_resume_gate( + LIVE_AGENT_STATE, + Some(STATUS_UNBOUND), + Some(true), + false, + false, + false + ), RestartResume::Skip, "a not-online record is not resurrected" ); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\livehost.rs:2108: // BELT (doyle Q1): user-terminal harness-hosted (controllable Some(false)) and // legacy/adapterless (None) fall OUT — never re-run (no dup risk). assert_eq!( - restart_resume_gate(LIVE_AGENT_STATE, Some(STATUS_ONLINE), Some(false), false, false, false), + restart_resume_gate( + LIVE_AGENT_STATE, + Some(STATUS_ONLINE), + Some(false), + false, + false, + false + ), RestartResume::Skip, "a user-terminal (controllable Some(false)) agent is excluded" ); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\livehost.rs:2115: assert_eq!( - restart_resume_gate(LIVE_AGENT_STATE, Some(STATUS_ONLINE), None, false, false, false), + restart_resume_gate( + LIVE_AGENT_STATE, + Some(STATUS_ONLINE), + None, + false, + false, + false + ), RestartResume::Skip, "a legacy None-controllable record is excluded (safe direction)" ); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\livehost.rs:2120: // A surviving broker session (brain restart, not a daemon-restart orphan) → Skip. assert_eq!( - restart_resume_gate(LIVE_AGENT_STATE, Some(STATUS_ONLINE), Some(true), true, false, false), + restart_resume_gate( + LIVE_AGENT_STATE, + Some(STATUS_ONLINE), + Some(true), + true, + false, + false + ), RestartResume::Skip, "an endpoint the broker still hosts is not orphaned" ); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\livehost.rs:2126: // BELT 1: a relay address means harness-hosted → Skip. assert_eq!( - restart_resume_gate(LIVE_AGENT_STATE, Some(STATUS_ONLINE), Some(true), false, true, false), + restart_resume_gate( + LIVE_AGENT_STATE, + Some(STATUS_ONLINE), + Some(true), + false, + true, + false + ), RestartResume::Skip, "a relay-addressed (harness-hosted) endpoint is excluded" ); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\livehost.rs:2132: // BELT 2: a live custody pid → RefuseLivePid (loud dup guard, NOT a silent skip). assert_eq!( - restart_resume_gate(LIVE_AGENT_STATE, Some(STATUS_ONLINE), Some(true), false, false, true), + restart_resume_gate( + LIVE_AGENT_STATE, + Some(STATUS_ONLINE), + Some(true), + false, + false, + true + ), RestartResume::RefuseLivePid, "a live custody pid refuses the re-run (never re-run over a live process)" ); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\msg.rs:1209: let back: EndpointInputReq = serde_json::from_value(serde_json::to_value(&req).unwrap()).unwrap(); assert_eq!(back.endpoint, "wall-b"); - assert_eq!(decode_bytes(&back.data_b64).unwrap(), decode_bytes(&req.data_b64).unwrap()); + assert_eq!( + decode_bytes(&back.data_b64).unwrap(), + decode_bytes(&req.data_b64).unwrap() + ); let env = endpoint_injected_envelope("wall-b", true, false); assert_eq!(env.kind, KIND_ENDPOINT_INJECTED); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\msg.rs:1287: serde_json::from_value(endpoint_injected_envelope("wall-b", false, false).payload) .unwrap(); assert!(!idle.delivered); - assert!(!idle.spool_deferred, "an IDLE-window spool hint is non-deferred (relay wakes)"); + assert!( + !idle.spool_deferred, + "an IDLE-window spool hint is non-deferred (relay wakes)" + ); // Delivered: delivered=true (spool_deferred ignored). let delivered: EndpointInjected = Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\msg.rs:1294: serde_json::from_value(endpoint_injected_envelope("wall-b", true, false).payload) .unwrap(); - assert!(delivered.delivered, "a binary-delivered reply carries delivered=true"); + assert!( + delivered.delivered, + "a binary-delivered reply carries delivered=true" + ); // N-1: an old broker omits `spool_deferred` → serde-defaults to false. let n1: EndpointInjected = Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\msg.rs:1334: // An EVEN older brain (pre-op_id too — only the two original fields). let oldest = json!({ "session_id": 1, "data_b64": encode_bytes(b"x") }); let req: InputReq = serde_json::from_value(oldest).unwrap(); - assert!(req.ack, "the oldest `input` shape still defaults to ack=true"); + assert!( + req.ack, + "the oldest `input` shape still defaults to ack=true" + ); assert_eq!(req.op_id, None); } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\msg.rs:1364: "ack=false must be serialized explicitly" ); let back: InputReq = serde_json::from_value(wire).unwrap(); - assert!(!back.ack, "ack=false survives the round-trip (no default clobber)"); + assert!( + !back.ack, + "ack=false survives the round-trip (no default clobber)" + ); assert_eq!(back.op_id, Some(42)); // And the acked direction round-trips as `true`. Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\msg.rs:1375: minter: None, ack: true, }; - let back: InputReq = - serde_json::from_value(serde_json::to_value(&acked).unwrap()).unwrap(); + let back: InputReq = serde_json::from_value(serde_json::to_value(&acked).unwrap()).unwrap(); assert!(back.ack, "ack=true round-trips as true"); } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\nethost.rs:44: use crate::broker::SharedSend; use crate::codec::write_frame; use crate::effect::Minter; -use crate::seedproofx::{prove_membership, MembershipSource, RosterExchange}; use crate::msg::{ net_presence_event_envelope, net_stream_data_envelope, net_stream_eof_envelope, NetPresenceEvent, NetStreamInfo, PRESENCE_CONNECTED, PRESENCE_DISCONNECTED, Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\nethost.rs:51: }; +use crate::seedproofx::{prove_membership, MembershipSource, RosterExchange}; /// The reserved [`crate::effect::EffectKey`] session namespace for net-scoped /// effects (a dial has no PTY session). Broker session ids are minted from 1 Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\nethost.rs:886: let membership = self.membership.clone(); // Snapshot the (opt-in) roster exchange + our live address for this dial. let roster_rx = self.roster.lock().unwrap().clone(); - let self_addr = serde_json::to_value(self.endpoint.addr()).unwrap_or(serde_json::Value::Null); + let self_addr = + serde_json::to_value(self.endpoint.addr()).unwrap_or(serde_json::Value::Null); // FIELD DIAG (PUMP-TRUTH W1, inert unless SPT_PUMP_DIAG set): the broker // dispatch REACHED the real QUIC dial — the lower half of doyle's arbiter. // An ENTER with no matching EXIT (or an EXIT > the 30s brain deadline) is Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\nethost.rs:942: /// the `apply_once` closure, so a concurrent deduped replay always finds it). /// The `minter` matches the journal key the broker built (ADR-0034 namespacing). pub fn record_dial_op(&self, minter: Minter, op_id: u64, conn_id: u64) { - self.dial_ops.lock().unwrap().insert((minter, op_id), conn_id); + self.dial_ops + .lock() + .unwrap() + .insert((minter, op_id), conn_id); } /// The connection a journaled dial `(minter, op_id)` opened, if this broker Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\nethost.rs:1522: ret.append(&[i]); } let (bytes, finished) = ret.drain(); - assert_eq!(bytes, (0..8u8).collect::>(), "retentive loses nothing, in order"); + assert_eq!( + bytes, + (0..8u8).collect::>(), + "retentive loses nothing, in order" + ); assert!(!finished); // …and a second drain is empty (the cursor consumed them exactly once). assert_eq!(ret.drain().0, Vec::::new()); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\nethost.rs:1533: for i in 0..8u8 { ord.append(&[i]); } - assert_eq!(ord.drain().0, vec![5, 6, 7], "ordinary keeps only the last cap chunks"); + assert_eq!( + ord.drain().0, + vec![5, 6, 7], + "ordinary keeps only the last cap chunks" + ); } // [unit->REQ-SHELL-4] the loopback tunnel pair under BACKPRESSURE (M11-W3, Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\notif.rs:997: .unwrap(); assert_eq!(row.kind, NOTIF_KIND_ROLLBACK); assert_eq!(row.from_id, "spt-update"); - assert!(row.body.contains("v9 failed"), "names the quarantined version"); - assert!(row.body.contains("rolled back to v8"), "names the running version"); + assert!( + row.body.contains("v9 failed"), + "names the quarantined version" + ); + assert!( + row.body.contains("rolled back to v8"), + "names the running version" + ); assert_eq!( fired, FirstFireOutcome::Fired { Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\pairhost.rs:762: let v = meet_failure_detail("IPv4-only", "meet probe timed out", 4, 75, 75, clock, true); assert!(v.contains("4 rendezvous attempt"), "attempt count: {v}"); assert!(v.contains("75s"), "elapsed/deadline: {v}"); - assert!(v.contains("bound families: IPv4-only"), "families (ties W1): {v}"); - assert!(v.contains("last error: meet probe timed out"), "last error kept: {v}"); + assert!( + v.contains("bound families: IPv4-only"), + "families (ties W1): {v}" + ); + assert!( + v.contains("last error: meet probe timed out"), + "last error kept: {v}" + ); // REQ-JOIN-VERBOSE-CLOCK: the joiner's step, signed offset, and // correction state all carried in the verbose block. assert!(v.contains("joiner clock:"), "clock line present: {v}"); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\pairhost.rs:853: ) .await; assert_eq!(got, Ok(7u32), "the post-refresh final sweep lands"); - assert_eq!(calls.get(), 2, "one exhausting probe + one post-refresh retry"); - assert!(refreshed.get(), "the refresh hook fired between the two probes"); + assert_eq!( + calls.get(), + 2, + "one exhausting probe + one post-refresh retry" + ); + assert!( + refreshed.get(), + "the refresh hook fired between the two probes" + ); } // [unit->REQ-HAZARD-CEREMONY-CLOCK-STEP] and if the final post-refresh sweep Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\pairhost.rs:878: ) .await; assert_eq!(got, Err("dead subnet"), "exhaustion error preserved"); - assert_eq!(calls.get(), 2, "exhausting probe + one final retry, then stop"); + assert_eq!( + calls.get(), + 2, + "exhausting probe + one final retry, then stop" + ); } } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\psyrelay.rs:341: }] ); assert_eq!(rows[0].from, "doyle-psyche"); - assert!(!rows[0].from.contains("evil-imposter") && !rows[0].body.contains("evil-imposter")); + assert!( + !rows[0].from.contains("evil-imposter") && !rows[0].body.contains("evil-imposter") + ); // The Psyche-addressed target received nothing. assert!(spool::drain_all_at(&victim).unwrap().is_empty()); }); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\pump\mod.rs:73: use crate::brain::Brain; use crate::config::DaemonConfig; -use crate::effect::{Minter, MintedOp}; +use crate::effect::{MintedOp, Minter}; use crate::registryhost::RegistryHost; use crate::sync::{SyncPolicy, SyncPullReport}; Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\pump\mod.rs:456: let mut registry_worker = RegistryWorker::new(Arc::clone(®istry), paths, &cadence); let mut notif_worker = NotifWorker::new(paths, &cadence); let mut sync_worker = SyncWorker::new(Arc::clone(®istry), paths, &cadence, hooks); - let mut update_worker = UpdateWorker::new(Arc::clone(®istry), paths, &cadence, full_auto_update); + let mut update_worker = + UpdateWorker::new(Arc::clone(®istry), paths, &cadence, full_auto_update); let mut workers: [&mut dyn PumpWorker; 4] = [ &mut registry_worker, &mut notif_worker, Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\pump\mod.rs:536: Ok(()) => "ok".to_string(), Err(e) => format!("err[{:?}] {e}", e.kind()), }; - crate::pump_diag!("LEG_EXIT i={i} ms={} {o}", leg_started.elapsed().as_millis()); + crate::pump_diag!( + "LEG_EXIT i={i} ms={} {o}", + leg_started.elapsed().as_millis() + ); } r }); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\pump\mod.rs:1009: } } - fn rec(cadence: Duration, wake: bool, log: &Rc>>, tag: char) -> RecordingWorker { + fn rec( + cadence: Duration, + wake: bool, + log: &Rc>>, + tag: char, + ) -> RecordingWorker { RecordingWorker { cadence, wake, Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\pump\mod.rs:1078: // pre_round once each for the two due workers, never for the not-due one. assert_eq!(l.iter().filter(|e| e.as_str() == "pre:a").count(), 1); assert_eq!(l.iter().filter(|e| e.as_str() == "pre:c").count(), 1); - assert!(!l.iter().any(|e| e == "pre:b"), "not-due leg never pre_rounds"); + assert!( + !l.iter().any(|e| e == "pre:b"), + "not-due leg never pre_rounds" + ); // All pre_rounds precede all peer_steps. let first_step = l.iter().position(|e| e.starts_with("step:")).unwrap(); assert!( Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\pump\mod.rs:1087: ); // peer_step runs for due indices only (0 and 2), once per peer (×2). assert_eq!(l.iter().filter(|e| e.as_str() == "step:0").count(), 2); - assert_eq!(l.iter().filter(|e| e.as_str() == "step:1").count(), 0, "not-due skipped"); + assert_eq!( + l.iter().filter(|e| e.as_str() == "step:1").count(), + 0, + "not-due skipped" + ); assert_eq!(l.iter().filter(|e| e.as_str() == "step:2").count(), 2); } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\pump\mod.rs:1106: Ok(()) } }); - assert!(res.is_err(), "the failure propagates so the shell drops the conn"); + assert!( + res.is_err(), + "the failure propagates so the shell drops the conn" + ); assert_eq!(seen, vec![0, 1], "aborted before the remaining due worker"); // Skip: a not-due index is never stepped. Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\pump\mod.rs:1196: // Ordinary error → conn dropped, round continues (Ok, not bubbled). let ordinary = io::Error::other("peer refused the stream"); assert!(peer_outcome(Err(ordinary), "bb", &mut conns).is_ok()); - assert!(!conns.contains_key("bb"), "an ordinary failure drops the conn"); + assert!( + !conns.contains_key("bb"), + "an ordinary failure drops the conn" + ); // TimedOut → bubbles out (Err): the supervisor restarts the pump with a // fresh client; the conn cache is rebuilt by the restart, not here. Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\pump\mod.rs:1363: }); assert_eq!(got, None); } - } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\pump\registry.rs:31: /// handle needed): the daemon re-reads `subnet.json` per connect, so the bump /// takes effect without a restart. // [impl->REQ-MESH-4] -fn fire_due_rotations(subnets_path: &std::path::Path, rotations_path: &std::path::Path, now_ms: u64) { +fn fire_due_rotations( + subnets_path: &std::path::Path, + rotations_path: &std::path::Path, + now_ms: u64, +) { let mut pending = spt_store::rotation::RotationPending::load_from(rotations_path); let due = pending.due_subnets(now_ms); if due.is_empty() { Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\pump\registry.rs:42: for sub in &due { match subnets.rotate_seed(sub) { Ok(rec) => { - eprintln!("SEED_ROTATED:{sub}:epoch={} (revoke window closed)", rec.epoch); + eprintln!( + "SEED_ROTATED:{sub}:epoch={} (revoke window closed)", + rec.epoch + ); rotated = true; } // The subnet may have been left/renamed since the revoke — drop the Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\pump\registry.rs:214: Some(before_home.seed_hex.as_str()), "prior seed retained for the grace" ); - assert_eq!(after.find("work").unwrap().epoch, 1, "not-due subnet untouched"); + assert_eq!( + after.find("work").unwrap().epoch, + 1, + "not-due subnet untouched" + ); let pend = spt_store::rotation::RotationPending::load_from(&rotations_path); assert!(!pend.subnets.contains_key("home"), "fired entry cleared"); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\pump\registry.rs:266: spt_store::perch::ParentHint::Infer, ); std::fs::create_dir_all(&p).unwrap(); - let rec = spt_store::info::InfoJson::new( - id, - "now", - std::process::id(), - "s", - "ready_agent", - ); + let rec = + spt_store::info::InfoJson::new(id, "now", std::process::id(), "s", "ready_agent"); spt_store::info::write_info(&p, &rec).unwrap(); let subnets_path = home.join("subnet.json"); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\pump\sync.rs:104: } if !want.is_empty() { let open_op = io.open_op()?; - let report = request_sync(&mut *io.brain, io.conn_id, &want, open_op, &cs, &self.scratch)?; + let report = request_sync( + &mut *io.brain, + io.conn_id, + &want, + open_op, + &cs, + &self.scratch, + )?; (self.hooks.on_pull)(peer_hex, &report); } Ok(()) Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\pump\update.rs:95: // expiry only. let cache = ReleaseCache::open(&self.releases); let base_policy = VerifyPolicy::load_from(&self.release_keys, 0, now_ms()); - let current = if cache.staged_channel().as_deref() - == Some(base_policy.pinned_channel.as_str()) - { - cache.staged_version().unwrap_or(0) - } else { - 0 - }; + let current = + if cache.staged_channel().as_deref() == Some(base_policy.pinned_channel.as_str()) { + cache.staged_version().unwrap_or(0) + } else { + 0 + }; let policy = VerifyPolicy { current_version: current, ..base_policy Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\pump\update.rs:124: .staged_version() .map(|v| v.to_string()) .unwrap_or_else(|| "?".to_string()); - eprintln!("UPDATE_STAGED:{version}:{:?} (from {})", plan.class, peer_hex); + eprintln!( + "UPDATE_STAGED:{version}:{:?} (from {})", + plan.class, peer_hex + ); // The operator-facing version label: the signed metadata's // semver (`product_version`) when present, else the monotonic // counter — never a bare counter in the consent notif. Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\reap.rs:307: assert!(matches!(child.try_wait(), Ok(None)), "child starts alive"); assert!(is_process_alive(gc), "grandchild starts alive"); reaper.reap(); - assert!(wait_exit(&mut child), "reap must terminate the enrolled child"); - assert!(wait_dead(gc), "reap must terminate the inherited grandchild"); + assert!( + wait_exit(&mut child), + "reap must terminate the enrolled child" + ); + assert!( + wait_dead(gc), + "reap must terminate the inherited grandchild" + ); let _ = std::fs::remove_file(&pidfile); } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\reap.rs:340: assert!(matches!(child.try_wait(), Ok(None)), "child starts alive"); assert!(is_process_alive(gc), "grandchild starts alive"); reaper.reap(); - assert!(wait_exit(&mut child), "reap must terminate the enrolled child"); - assert!(wait_dead(gc), "reap must terminate the inherited grandchild"); + assert!( + wait_exit(&mut child), + "reap must terminate the enrolled child" + ); + assert!( + wait_dead(gc), + "reap must terminate the inherited grandchild" + ); let _ = std::fs::remove_file(&pidfile); } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\registryhost.rs:446: info.as_ref().is_some_and(|i| i.controlled), &self.node_hex, ); - let harness_only = info.as_ref().is_some_and(|i| { - i.state == "live_agent" && i.controllable != Some(true) - }); + let harness_only = info + .as_ref() + .is_some_and(|i| i.state == "live_agent" && i.controllable != Some(true)); // The #4 de-faking datums (REQ-GOSSIP-ADAPTER-PROJECTS): the endpoint's // real harness adapter + its recent projects + the EXPLICIT any-controller // truth, gossiped so `from_resource_row` stops faking remote rows. Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\registryhost.rs:573: endpoint_id: id, instance, })); - eprintln!("ROSTER_GHOST_HEAL:{}: erased perch advertised offline", sub.name); + eprintln!( + "ROSTER_GHOST_HEAL:{}: erased perch advertised offline", + sub.name + ); } } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\registryhost.rs:1308: label: "BOX".into(), machine_id: "mid-1".into(), }; - let notices = - repair_evict_superseded(&mut roster, "home", "new-key", &intro, &snap_dir); + let notices = repair_evict_superseded(&mut roster, "home", "new-key", &intro, &snap_dir); // The demoted warn-on-change: one machine_id-anchored notice K1→K2. assert_eq!( Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\registryhost.rs:1360: }; let none = repair_evict_superseded(&mut r2, "home", "new-key", &other, &snap_dir); assert!(none.is_empty(), "no-match raises no rekey notice"); - assert!(r2.is_member("home", "unrelated"), "no-match leaves roster intact"); + assert!( + r2.is_member("home", "unrelated"), + "no-match leaves roster intact" + ); assert!(!RegistryHost::repair_evict_path(&snap_dir).exists()); // Absent machine id: a FRESH gossip snapshot with a labeled identity; Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\registryhost.rs:1390: }; let silent = repair_evict_superseded(&mut r3, "home", "new-key", &no_id, &snap2); assert!(silent.is_empty(), "absent machine id → no false notice"); - assert!(r3.is_member("home", "old2"), "absent-id leaves roster intact"); + assert!( + r3.is_member("home", "old2"), + "absent-id leaves roster intact" + ); } // [unit->REQ-INST-7] inbound feeds gate fail-closed: non-member subnet Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\registryhost.rs:1664: ); // The label landed and is the only carrier — no endpoint row created. let snap = RegistryHost::snapshot_path(&dir.path().join("registry"), "home"); - let reg: SubnetRegistry = - serde_json::from_slice(&std::fs::read(&snap).unwrap()).unwrap(); - assert_eq!(reg.node_labels().collect::>(), vec![("bb22", "RENAMED")]); - assert!(reg.endpoint_ids().next().is_none(), "no phantom endpoint row"); + let reg: SubnetRegistry = serde_json::from_slice(&std::fs::read(&snap).unwrap()).unwrap(); + assert_eq!( + reg.node_labels().collect::>(), + vec![("bb22", "RENAMED")] + ); + assert!( + reg.endpoint_ids().next().is_none(), + "no phantom endpoint row" + ); } // [unit->REQ-INST-3] registry advertisement FOLLOWS the resting-state Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\registryhost.rs:1833: &InfoJson::new("live", "now", std::process::id(), "s", "live_agent"), ) .unwrap(); - assert_eq!(advertised_status(&p), Status::Active, "baseline: bound+alive ⇒ Active"); + assert_eq!( + advertised_status(&p), + Status::Active, + "baseline: bound+alive ⇒ Active" + ); // Stamp a host-level failure report — the derivation must not change. - info::set_host_error(&p, Some("wake-resume: adapter 'ghost' is not registered")).unwrap(); + info::set_host_error(&p, Some("wake-resume: adapter 'ghost' is not registered")) + .unwrap(); assert_eq!( advertised_status(&p), Status::Active, Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\registryhost.rs:1888: "offline heal advertised to peers: {out:?}" ); // No longer a routable (Active) resource → resource_projection drops it. - let rows = spt_net::net::registry::resource_projection( - &h.regs.lock().unwrap()["adv"], - |_| false, - ); + let rows = + spt_net::net::registry::resource_projection(&h.regs.lock().unwrap()["adv"], |_| { + false + }); assert!( rows.iter().all(|r| r.endpoint_id != "ghost-ag"), "erased endpoint no longer projects as a live resource" Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\registryhost.rs:2086: // the ghost survives (eviction must not race a row that just went Offline). assert_eq!(h.evict_aged_offline_rows_at(grace, 1_000), 0); assert_eq!(h.evict_aged_offline_rows_at(grace, 1_000 + 299_000), 0); - assert_eq!(h.rows("home", "ghost").len(), 1, "within grace the ghost survives"); + assert_eq!( + h.rows("home", "ghost").len(), + 1, + "within grace the ghost survives" + ); // Past the grace the aged Offline ghost evicts and the snapshot is rewritten. let later = 1_000 + 300_000 + 1; Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\registryhost.rs:2093: assert_eq!(h.evict_aged_offline_rows_at(grace, later), 1); - assert!(h.rows("home", "ghost").is_empty(), "aged Offline ghost evicted"); + assert!( + h.rows("home", "ghost").is_empty(), + "aged Offline ghost evicted" + ); let snap = RegistryHost::snapshot_path(&dir.path().join("registry"), "home"); let parsed: SubnetRegistry = serde_json::from_slice(&std::fs::read(&snap).unwrap()).unwrap(); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\relay.rs:62: /// killed one left behind. Returns the number of messages forwarded. pub fn drain_backlog(&self, mut sink: F) -> usize { // [impl->REQ-SPOOL-TAKE-AUDIT] relay-backlog leg — stamp who drained the row. - let audit = - spool::TakerAudit::new(spool::TakerLeg::RelayBacklog, None, Some(std::process::id())); - let msgs = spool::drain_non_deferred_audited_at(&self.perch_path, &audit).unwrap_or_default(); + let audit = spool::TakerAudit::new( + spool::TakerLeg::RelayBacklog, + None, + Some(std::process::id()), + ); + let msgs = + spool::drain_non_deferred_audited_at(&self.perch_path, &audit).unwrap_or_default(); let n = msgs.len(); for m in &msgs { sink(&m.from, &m.body); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\release.rs:599: /// adapter's declared `signing_key`. **Fail-closed:** any malformed signature or /// mismatch returns an error and the bytes are never trusted (REQ-UPD-9). // [impl->REQ-UPD-9] -pub fn verify_detached(bytes: &[u8], signature_hex: &str, key: &VerifyingKey) -> Result<(), RejectReason> { +pub fn verify_detached( + bytes: &[u8], + signature_hex: &str, + key: &VerifyingKey, +) -> Result<(), RejectReason> { let sig_bytes = hex_decode(signature_hex).map_err(RejectReason::Malformed)?; let sig_arr: [u8; 64] = sig_bytes.as_slice().try_into().map_err(|_| { RejectReason::Malformed(format!("signature is {} bytes, want 64", sig_bytes.len())) Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\resting.rs:547: Ok(report) => RestRoute::Local(report), Err(e) if allow_remote_fallback && e.contains(NOT_A_HOSTED_PERCH_MARKER) => { let goal = match event { - RestEvent::Wake => RestGoal { target: Status::Active, kind: GoalKind::Exists }, - RestEvent::Suspend => { - RestGoal { target: Status::Suspended, kind: GoalKind::Forall } - } + RestEvent::Wake => RestGoal { + target: Status::Active, + kind: GoalKind::Exists, + }, + RestEvent::Suspend => RestGoal { + target: Status::Suspended, + kind: GoalKind::Forall, + }, _ => return RestRoute::NoRemoteArm, }; match select_rest_target(&load_candidates(), goal) { Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\resting.rs:580: fn route_rest_event_contract_table() { use spt_net::net::registry::Status; let miss = || Err(format!("info.json absent — {NOT_A_HOSTED_PERCH_MARKER}")); - let no_candidates_expected = || -> Vec<(String, Status)> { - panic!("load_candidates must not run on a local path") - }; + let no_candidates_expected = + || -> Vec<(String, Status)> { panic!("load_candidates must not run on a local path") }; // Local edge + local no-edge pass through, candidates never loaded. assert!(matches!( Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\resting.rs:909: assert_eq!(effective_rest_state(true, false, None), Active); assert_eq!(effective_rest_state(true, false, Some(Active)), Active); assert_eq!(effective_rest_state(true, false, Some(Dormant)), Dormant); - assert_eq!(effective_rest_state(true, false, Some(Suspended)), Suspended); + assert_eq!( + effective_rest_state(true, false, Some(Suspended)), + Suspended + ); // unbound (warm skeleton): Dormant for EVERY intent, incl. void. for intent in [None, Some(Active), Some(Dormant), Some(Suspended)] { Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\rollback_compat.rs:125: candidate_started_ms: 1_234, prior_version: Some(6), }, - &["phase", "version", "rollback_binary", "candidate_started_ms"], + &[ + "phase", + "version", + "rollback_binary", + "candidate_started_ms", + ], ); - assert_additive_n1_readable(&AppliedRecord::Applied { version: 7 }, &["phase", "version"]); assert_additive_n1_readable( + &AppliedRecord::Applied { version: 7 }, + &["phase", "version"], + ); + assert_additive_n1_readable( &AppliedRecord::RolledBack { quarantine_version: 7, running_version: 6, Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\rollback_compat.rs:135: rollback_binary: "/opt/spt/spt.old-6".to_string(), }, - &["phase", "quarantine_version", "running_version", "rollback_binary"], + &[ + "phase", + "quarantine_version", + "running_version", + "rollback_binary", + ], ); // D6-1b + D7-1: brain.ready (`{pid, generation, exe_hash}`) — no struct; Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\rollback_compat.rs:145: let ready = serde_json::json!({ "pid": 4321, "generation": 9, "exe_hash": "ab12" }); let obj = ready.as_object().unwrap(); assert!( - obj.contains_key("pid") && obj.contains_key("generation") && obj.contains_key("exe_hash") + obj.contains_key("pid") + && obj.contains_key("generation") + && obj.contains_key("exe_hash") ); let with_extra = serde_json::json!({ "pid": 4321, "generation": 9, "exe_hash": "ab12", "spt_future_additive_field": "x" Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\seedmap.rs:447: }); for _ in 0..400 { if ping(&name).is_ok() { - return SeedServer { name, stopped: false }; + return SeedServer { + name, + stopped: false, + }; } std::thread::sleep(Duration::from_millis(5)); } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\seedproofx.rs:221: ProofRole::Dialer => (local_id, remote), ProofRole::Acceptor => (remote, local_id), }; - let by_name: HashMap<&str, &SubnetCred> = - creds.iter().map(|c| (c.name.as_str(), c)).collect(); + let by_name: HashMap<&str, &SubnetCred> = creds.iter().map(|c| (c.name.as_str(), c)).collect(); match role { ProofRole::Dialer => { Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\seedproofx.rs:277: /// The `(epoch, tag)` set this node sends for the subnet, proving each /// generation it holds in role `mine` (current first). fn outbound(&self, mine: ProofRole) -> Vec<(u64, [u8; 32])> { - let mut out = vec![(self.current.epoch, self.current.transcript.tag(&self.current.mk, mine))]; + let mut out = vec![( + self.current.epoch, + self.current.transcript.tag(&self.current.mk, mine), + )]; if let Some(p) = &self.prev { out.push((p.epoch, p.transcript.tag(&p.mk, mine))); } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\seedproofx.rs:341: for name in shared { let cred = by_name.get(name.as_str())?; let current = gen_proof( - &cred.seed, name, cred.epoch, dialer_pub, acceptor_pub, nonce_d, nonce_a, + &cred.seed, + name, + cred.epoch, + dialer_pub, + acceptor_pub, + nonce_d, + nonce_a, ); let prev = cred.prev.as_ref().map(|(seed, epoch)| { - gen_proof(seed, name, *epoch, dialer_pub, acceptor_pub, nonce_d, nonce_a) + gen_proof( + seed, + name, + *epoch, + dialer_pub, + acceptor_pub, + nonce_d, + nonce_a, + ) }); out.push(LocalGens { name: name.clone(), Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\seedproofx.rs:357: /// This peer's roster status for a subnet, via the (opt-in) roster seam. `None` /// when no seam is wired — the mechanics-only path grades on epoch alone. -fn peer_status(roster: Option<&RosterExchange>, subnet: &str, peer_hex: &str) -> Option { +fn peer_status( + roster: Option<&RosterExchange>, + subnet: &str, + peer_hex: &str, +) -> Option { roster.map(|rx| (rx.member_status)(subnet, peer_hex)) } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\seedproofx.rs:407: ) -> Option> { let nonce_d = fresh_nonce(); let my_names: Vec = creds.iter().map(|c| c.name.clone()).collect(); - write_frame(send, &SeedProofFrame::Hello { nonce: nonce_d, subnets: my_names }.encode()) - .await?; + write_frame( + send, + &SeedProofFrame::Hello { + nonce: nonce_d, + subnets: my_names, + } + .encode(), + ) + .await?; // Acceptor replies with the intersection (in its order) + its nonce. - let (nonce_a, shared) = match read_frame(recv, MAX_FRAME).await.and_then(|b| SeedProofFrame::decode(&b)) { + let (nonce_a, shared) = match read_frame(recv, MAX_FRAME) + .await + .and_then(|b| SeedProofFrame::decode(&b)) + { Some(SeedProofFrame::Hello { nonce, subnets }) => (nonce, subnets), _ => return None, }; Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\seedproofx.rs:427: // per subnet (Mesh-D7), so a peer one epoch ahead or behind can still match. // They buffer while the acceptor reads, so the ping-pong never deadlocks. for g in &gens { - write_frame(send, &SeedProofFrame::ProofSet { proofs: g.outbound(ProofRole::Dialer) }.encode()) - .await?; + write_frame( + send, + &SeedProofFrame::ProofSet { + proofs: g.outbound(ProofRole::Dialer), + } + .encode(), + ) + .await?; } // Then read the acceptor's proof sets (no early abort — grade after the full // read so the legs below stay symmetric with the acceptor; tombstone grading Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\seedproofx.rs:435: // is one-sided, so an aborting verify would desync the stream). let mut peer_sets = Vec::with_capacity(gens.len()); for _ in &gens { - match read_frame(recv, MAX_FRAME).await.and_then(|b| SeedProofFrame::decode(&b)) { + match read_frame(recv, MAX_FRAME) + .await + .and_then(|b| SeedProofFrame::decode(&b)) + { Some(SeedProofFrame::ProofSet { proofs }) => peer_sets.push(proofs), _ => return None, } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\seedproofx.rs:479: roster: Option<&RosterExchange>, self_addr: &serde_json::Value, ) -> Option> { - let (nonce_d, dialer_names) = match read_frame(recv, MAX_FRAME).await.and_then(|b| SeedProofFrame::decode(&b)) { + let (nonce_d, dialer_names) = match read_frame(recv, MAX_FRAME) + .await + .and_then(|b| SeedProofFrame::decode(&b)) + { Some(SeedProofFrame::Hello { nonce, subnets }) => (nonce, subnets), _ => return None, }; Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\seedproofx.rs:494: let nonce_a = fresh_nonce(); write_frame( send, - &SeedProofFrame::Hello { nonce: nonce_a, subnets: shared.clone() }.encode(), + &SeedProofFrame::Hello { + nonce: nonce_a, + subnets: shared.clone(), + } + .encode(), ) .await?; if shared.is_empty() { Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\seedproofx.rs:508: // send-then-read, so the ping-pong stays deadlock-free). let mut peer_sets = Vec::with_capacity(gens.len()); for _ in &gens { - match read_frame(recv, MAX_FRAME).await.and_then(|b| SeedProofFrame::decode(&b)) { + match read_frame(recv, MAX_FRAME) + .await + .and_then(|b| SeedProofFrame::decode(&b)) + { Some(SeedProofFrame::ProofSet { proofs }) => peer_sets.push(proofs), _ => return None, } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\seedproofx.rs:515: } for g in &gens { - write_frame(send, &SeedProofFrame::ProofSet { proofs: g.outbound(ProofRole::Acceptor) }.encode()) - .await?; + write_frame( + send, + &SeedProofFrame::ProofSet { + proofs: g.outbound(ProofRole::Acceptor), + } + .encode(), + ) + .await?; } let graded = grade_all(&gens, &peer_sets, ProofRole::Dialer, remote_hex, roster); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\seedproofx.rs:528: /// Write a length-delimited frame (`u32` BE length prefix + body). async fn write_frame(send: &mut SendStream, body: &[u8]) -> Option<()> { - send.write_all(&(body.len() as u32).to_be_bytes()).await.ok()?; + send.write_all(&(body.len() as u32).to_be_bytes()) + .await + .ok()?; send.write_all(body).await.ok()?; Some(()) } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\seedproofx.rs:562: /// live address (`self_addr`) onto its advertised self-entry so peers learn how /// to reach it. `proven` is the set both sides verified; `self_addr` is the /// opaque dialable-address JSON (`Null` ⇒ advertise no address). -pub type RosterProvider = - Arc, &serde_json::Value) -> (Vec, Vec) + Send + Sync>; +pub type RosterProvider = Arc< + dyn Fn(&HashSet, &serde_json::Value) -> (Vec, Vec) + + Send + + Sync, +>; /// Merges a received roster slice into the durable store and reconciles the dial /// cache (gap-fill). Receives the peer's advertised entries + tombstones. Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\seedproofx.rs:610: // desyncs against a peer that does. `proven` is empty ⇒ an empty slice. let Some(rx) = roster else { return }; let (entries, tombstones) = (rx.provider)(proven, self_addr); - if write_frame(send, &enc_roster(&entries, &tombstones)).await.is_none() { + if write_frame(send, &enc_roster(&entries, &tombstones)) + .await + .is_none() + { return; } if let Some(body) = read_frame(recv, MAX_FRAME).await { Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\seedproofx.rs:658: fn seed_pushes(reseed: &[String], by_name: &HashMap<&str, &SubnetCred>) -> Vec { reseed .iter() - .filter_map(|n| by_name.get(n.as_str()).map(|c| (n.clone(), c.seed.clone(), c.epoch))) + .filter_map(|n| { + by_name + .get(n.as_str()) + .map(|c| (n.clone(), c.seed.clone(), c.epoch)) + }) .collect() } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\seedproofx.rs:895: .unwrap_or_default(); let provider_hex = self_hex.clone(); RosterExchange { - provider: Arc::new(move |proven: &HashSet, self_addr: &serde_json::Value| { - let mut store = RosterStore::load(); - let label = spt_store::hostlabel::os_hostname().unwrap_or_default(); - let machine_id = crate::machineid::machine_id_hash().unwrap_or_default(); - // Peek, never consume: roster propagation must not disturb the - // registry lease counter (the D3 rule). - let lease = spt_store::epoch::EpochSource::load().current(); - let now = now_secs().to_string(); - let addr = if self_addr.is_null() { - None - } else { - Some(self_addr.clone()) - }; - for s in proven { - store.upsert_self(s, &provider_hex, &label, &machine_id, addr.clone(), &now, lease); - } - let _ = store.save(); - let mut entries = Vec::new(); - let mut tombstones = Vec::new(); - for s in proven { - let (m, t) = store.roster_for(s); - entries.extend(m); - tombstones.extend(t); - } - (entries, tombstones) - }), - sink: Arc::new(move |entries: Vec, tombstones: Vec| { - let mut store = RosterStore::load(); - for e in &entries { - store.merge_entry(e.clone()); - } - for t in &tombstones { - store.tombstone(&t.subnet, &t.pubkey_hex, &t.stamp); - } - let _ = store.save(); - let path = spt_store::peeraddrs::peer_addrs_file(); - let mut pa = PeerAddrStore::load_from(&path); - if gapfill_peeraddrs(&mut pa, &self_hex, &entries) { - let _ = pa.save_to(&path); - } - }), + provider: Arc::new( + move |proven: &HashSet, self_addr: &serde_json::Value| { + let mut store = RosterStore::load(); + let label = spt_store::hostlabel::os_hostname().unwrap_or_default(); + let machine_id = crate::machineid::machine_id_hash().unwrap_or_default(); + // Peek, never consume: roster propagation must not disturb the + // registry lease counter (the D3 rule). + let lease = spt_store::epoch::EpochSource::load().current(); + let now = now_secs().to_string(); + let addr = if self_addr.is_null() { + None + } else { + Some(self_addr.clone()) + }; + for s in proven { + store.upsert_self( + s, + &provider_hex, + &label, + &machine_id, + addr.clone(), + &now, + lease, + ); + } + let _ = store.save(); + let mut entries = Vec::new(); + let mut tombstones = Vec::new(); + for s in proven { + let (m, t) = store.roster_for(s); + entries.extend(m); + tombstones.extend(t); + } + (entries, tombstones) + }, + ), + sink: Arc::new( + move |entries: Vec, tombstones: Vec| { + let mut store = RosterStore::load(); + for e in &entries { + store.merge_entry(e.clone()); + } + for t in &tombstones { + store.tombstone(&t.subnet, &t.pubkey_hex, &t.stamp); + } + let _ = store.save(); + let path = spt_store::peeraddrs::peer_addrs_file(); + let mut pa = PeerAddrStore::load_from(&path); + if gapfill_peeraddrs(&mut pa, &self_hex, &entries) { + let _ = pa.save_to(&path); + } + }, + ), // Mesh-D7 (REQ-MESH-4): the peer's roster status gates the grace — // tombstoned ⇒ revoked ⇒ denied; listed ⇒ present; otherwise absent. // Re-read per call so a just-propagated tombstone takes effect at once. Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\seedproofx.rs:1002: #[test] fn roster_frame_round_trips() { let entries = vec![ - entry("aa", "home", Some(serde_json::json!({"id": "aa", "addrs": ["10.0.0.1:7"]})), 3), + entry( + "aa", + "home", + Some(serde_json::json!({"id": "aa", "addrs": ["10.0.0.1:7"]})), + 3, + ), entry("bb", "home", None, 1), entry("cc", "work", Some(serde_json::json!({"id": "cc"})), 9), ]; Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\seedproofx.rs:1009: let tombstones = vec![tomb("dd", "home")]; let buf = enc_roster(&entries, &tombstones); let (de, dt) = dec_roster(&buf).expect("round-trip"); - assert_eq!(de, entries, "entries (incl. explicit subnet + address) survive"); + assert_eq!( + de, entries, + "entries (incl. explicit subnet + address) survive" + ); assert_eq!(dt, tombstones, "tombstones survive"); } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\seedproofx.rs:1060: let entries = vec![ entry("self", "home", Some(serde_json::json!({"id": "self"})), 1), // skipped entry("cc", "home", Some(addr_c.clone()), 1), // absent ⇒ fill - entry("bb", "home", Some(advertised_b), 1), // present ⇒ keep observed + entry("bb", "home", Some(advertised_b), 1), // present ⇒ keep observed ]; assert!(gapfill_peeraddrs(&mut pa, "self", &entries), "C was filled"); - assert_eq!(pa.get("cc"), Some(&addr_c), "absent member filled from roster"); - assert_eq!(pa.get("bb"), Some(&observed_b), "observed addr not clobbered"); + assert_eq!( + pa.get("cc"), + Some(&addr_c), + "absent member filled from roster" + ); + assert_eq!( + pa.get("bb"), + Some(&observed_b), + "observed addr not clobbered" + ); assert_eq!(pa.get("self"), None, "own entry skipped"); // Idempotent: a second pass with the same input changes nothing. Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\seedproofx.rs:1071: - assert!(!gapfill_peeraddrs(&mut pa, "self", &entries), "no further change"); + assert!( + !gapfill_peeraddrs(&mut pa, "self", &entries), + "no further change" + ); } } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\seedproofx.rs:1088: // exact-epoch (matched_current = true) assert_eq!(grade_subnet(true, false, Some(Present)), Full); - assert_eq!(grade_subnet(true, false, Some(Absent)), Full, "unknown member, current seed ⇒ admit"); - assert_eq!(grade_subnet(true, false, Some(Tombstoned)), Denied, "revokee denied even exact"); + assert_eq!( + grade_subnet(true, false, Some(Absent)), + Full, + "unknown member, current seed ⇒ admit" + ); + assert_eq!( + grade_subnet(true, false, Some(Tombstoned)), + Denied, + "revokee denied even exact" + ); // prior-epoch only (matched_prev = true, matched_current = false) - assert_eq!(grade_subnet(false, true, Some(Present)), ReseedOnly, "benign offliner ⇒ grace"); - assert_eq!(grade_subnet(false, true, Some(Tombstoned)), Denied, "revoked N-1 ⇒ denied"); - assert_eq!(grade_subnet(false, true, Some(Absent)), Denied, "off-roster N-1 ⇒ never re-seeded"); + assert_eq!( + grade_subnet(false, true, Some(Present)), + ReseedOnly, + "benign offliner ⇒ grace" + ); + assert_eq!( + grade_subnet(false, true, Some(Tombstoned)), + Denied, + "revoked N-1 ⇒ denied" + ); + assert_eq!( + grade_subnet(false, true, Some(Absent)), + Denied, + "off-roster N-1 ⇒ never re-seeded" + ); // ≥2 stale / forged (no match at any held generation) assert_eq!(grade_subnet(false, false, Some(Present)), Denied); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\seedproofx.rs:1117: ]; let buf = enc_seedxfer(&items); assert_eq!(dec_seedxfer(&buf), Some(items.clone()), "round-trip"); - assert_eq!(dec_seedxfer(&enc_seedxfer(&[])), Some(vec![]), "empty round-trip"); + assert_eq!( + dec_seedxfer(&enc_seedxfer(&[])), + Some(vec![]), + "empty round-trip" + ); assert_eq!(dec_seedxfer(&[]), None, "empty buffer (no count)"); assert_eq!(dec_seedxfer(&[0, 0, 0, 1]), None, "count claims 1, no item"); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\seedproofx.rs:1150: // ...but it IS present in the confidential transfer leg (proving that is // the only channel it travels). let xfer = enc_seedxfer(&[("home".to_string(), seed.clone(), 2)]); - assert!(contains_subslice(&xfer, &seed), "the seed rides the transfer leg"); + assert!( + contains_subslice(&xfer, &seed), + "the seed rides the transfer leg" + ); } fn contains_subslice(hay: &[u8], needle: &[u8]) -> bool { Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\serveprobe.rs:67: /// request runs. No gate (module docs): the answer is public serve-state, the /// QUIC handshake is the only subject that matters. // [impl->REQ-SUBNET-5] -pub fn serve_subnet_probe( - brain: &mut Brain, - stream_id: u64, -) -> io::Result { +pub fn serve_subnet_probe(brain: &mut Brain, stream_id: u64) -> io::Result { brain.net_stream_subscribe(stream_id, 0)?; let mut decoder = ServeProbeDecoder::new(); loop { Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\service.rs:420: None => std::env::remove_var("SPT_HOME"), } assert!(!overridden, "SPT_HOME set ⇒ not the service's home"); - assert!(default, "no SPT_HOME ⇒ the default home the service manages"); + assert!( + default, + "no SPT_HOME ⇒ the default home the service manages" + ); } // [unit->REQ-DAEMON-6] the systemd unit path is the install.sh target: Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\service.rs:434: ); assert_eq!( systemd_unit_path_from(None, Some("/home/u")), - Some(PathBuf::from("/home/u/.config/systemd/user/spt-daemon.service")) + Some(PathBuf::from( + "/home/u/.config/systemd/user/spt-daemon.service" + )) ); assert_eq!( systemd_unit_path_from(Some(""), Some("/home/u")), Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\service.rs:441: - Some(PathBuf::from("/home/u/.config/systemd/user/spt-daemon.service")) + Some(PathBuf::from( + "/home/u/.config/systemd/user/spt-daemon.service" + )) ); assert_eq!(systemd_unit_path_from(None, None), None); } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\shellchan.rs:35: use spt_runtime::manifest::Shell; use crate::brain::{now_ms, Brain, BrokerEvent}; -use crate::effect::{Minter, MintedOp}; +use crate::effect::{MintedOp, Minter}; use crate::shellhost::{frame_mac, verify_frame_mac}; /// The broker session label for a stdin-hosted shell instance — path-shaped so Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\shellhost.rs:131: ]); // [impl->REQ-HAZARD-TEMPLATE-ARGV-FILL] tokenize-template-then-fill-each: a // multi-word/quote/semicolon {key} value is exactly one argv element. - let tokens = - spt_runtime::runtime::fill_template_tokens(&shell.spawn, &keys).map_err(|e| e.to_string())?; + let tokens = spt_runtime::runtime::fill_template_tokens(&shell.spawn, &keys) + .map_err(|e| e.to_string())?; if tokens.is_empty() { return Err("empty spawn command".into()); } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\shellwake.rs:379: // The wake-forward rest op's seq source is a fresh `now_ms()` — its OWN // minting source, distinct from shellchan's spool-row counter (doyle ruling: // the tag names the seq source, not the subsystem), so it stamps `wake`. - || Ok(crate::effect::MintedOp::new(crate::effect::Minter::Wake, now_ms())), + || { + Ok(crate::effect::MintedOp::new( + crate::effect::Minter::Wake, + now_ms(), + )) + }, |op| { let conn = brain.net_dial(addr.clone(), None)?; // Keep the tracing string's seq consistent with the (possibly re-minted) op. Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\shellwake.rs:447: ]); // [impl->REQ-HAZARD-TEMPLATE-ARGV-FILL] tokenize-template-then-fill-each: a // multi-word/quote/semicolon {key} value is exactly one argv element. - let tokens = - spt_runtime::runtime::fill_template_tokens(wake_command, &keys).map_err(|e| e.to_string())?; + let tokens = spt_runtime::runtime::fill_template_tokens(wake_command, &keys) + .map_err(|e| e.to_string())?; if tokens.is_empty() { return Err("empty wake_command".into()); } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\shellwake.rs:993: 1, "only the profiled instance (overlay adds wake_command) gets a watcher" ); - assert!(set.contains("doyle", &pid), "the profiled instance is the one watched"); + assert!( + set.contains("doyle", &pid), + "the profiled instance is the one watched" + ); set.stop_watcher(owlery, "doyle", &pid); } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\stderrlog.rs:136: pub fn install(role: &str, generation: u64) -> Option { let dir = stderr_log_dir(); if let Err(e) = std::fs::create_dir_all(&dir) { - eprintln!("STDERR_PERSIST_SKIP: could not create {}: {e}", dir.display()); + eprintln!( + "STDERR_PERSIST_SKIP: could not create {}: {e}", + dir.display() + ); return None; } let path = stderr_log_path(); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\stderrlog.rs:145: if should_roll(size, STDERR_LOG_CAP) { roll_files(&dir, STDERR_LOG_KEEP); } - let mut file = match std::fs::OpenOptions::new().create(true).append(true).open(&path) { + let mut file = match std::fs::OpenOptions::new() + .create(true) + .append(true) + .open(&path) + { Ok(f) => f, Err(e) => { - eprintln!("STDERR_PERSIST_SKIP: could not open {}: {e}", path.display()); + eprintln!( + "STDERR_PERSIST_SKIP: could not open {}: {e}", + path.display() + ); return None; } }; Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\stderrlog.rs:169: #[test] fn should_roll_at_or_over_cap_only() { assert!(!should_roll(0, STDERR_LOG_CAP), "empty never rolls"); - assert!(!should_roll(STDERR_LOG_CAP - 1, STDERR_LOG_CAP), "just under never rolls"); - assert!(should_roll(STDERR_LOG_CAP, STDERR_LOG_CAP), "exactly at cap rolls"); - assert!(should_roll(STDERR_LOG_CAP + 1, STDERR_LOG_CAP), "over cap rolls"); + assert!( + !should_roll(STDERR_LOG_CAP - 1, STDERR_LOG_CAP), + "just under never rolls" + ); + assert!( + should_roll(STDERR_LOG_CAP, STDERR_LOG_CAP), + "exactly at cap rolls" + ); + assert!( + should_roll(STDERR_LOG_CAP + 1, STDERR_LOG_CAP), + "over cap rolls" + ); assert!(!should_roll(u64::MAX, 0), "cap 0 disables rotation"); } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\stderrlog.rs:190: roll_files(dir.path(), STDERR_LOG_KEEP); // The old backup is dropped; the current became the new .1. - assert!(!cur.exists(), "current was rolled away (fresh install reopens it)"); + assert!( + !cur.exists(), + "current was rolled away (fresh install reopens it)" + ); assert_eq!( std::fs::read(&bak).unwrap(), b"CURRENT-A", Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\stderrlog.rs:197: "the current file's content is preserved as the .1 backup" ); // No .2 accumulates (KEEP=2 keeps only current + .1). - assert!(!rolled_path(dir.path(), 2).exists(), "no unbounded accumulation"); + assert!( + !rolled_path(dir.path(), 2).exists(), + "no unbounded accumulation" + ); } // [unit->REQ-DAEMON-STDERR-PERSIST] KEEP<=1 keeps NO backup — the current file is Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\stderrlog.rs:210: std::fs::write(&cur, b"CURRENT").unwrap(); roll_files(dir.path(), 1); assert!(!cur.exists(), "keep=1 clears the current file"); - assert!(!rolled_path(dir.path(), 1).exists(), "keep=1 makes no backup"); + assert!( + !rolled_path(dir.path(), 1).exists(), + "keep=1 makes no backup" + ); } // [unit->REQ-DAEMON-STDERR-PERSIST] the log path derivation sits under SPT_HOME Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\stderrlog.rs:225: assert!(p.parent().unwrap().ends_with("logs")); }); let stamp = stamp_line("broker", 7); - assert!(stamp.contains("broker") && stamp.contains("generation 7"), "got {stamp}"); + assert!( + stamp.contains("broker") && stamp.contains("generation 7"), + "got {stamp}" + ); assert!(!stamp.contains("REQ-"), "no internal tag leaks: {stamp}"); } } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\sync.rs:362: // LANDED — so if the leg now wedges on the 30s deadline, the culprit is the // reply-READ below (`read_event_until`), i.e. a peer that connected + accepted // the sync stream but never sends a response. Inert unless SPT_PUMP_DIAG set. - crate::pump_diag!("SYNC_REQ_SENT stream={stream_id} refs={} waiting reply-read", refs.len()); + crate::pump_diag!( + "SYNC_REQ_SENT stream={stream_id} refs={} waiting reply-read", + refs.len() + ); std::fs::create_dir_all(scratch_dir)?; let bundle: PathBuf = scratch_dir.join(format!("recv-{}.bundle", safe_stem(&sync_id))); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\sync.rs:510: // literal, not merely a matter of role conflicts being rare (REQ-EP-7). // [impl->REQ-EP-7] if std::path::Path::new(&file).file_name() - == Some(std::ffi::OsStr::new(spt_store::contextstore::LIVE_ROLE_FILE)) + == Some(std::ffi::OsStr::new( + spt_store::contextstore::LIVE_ROLE_FILE, + )) { outcomes.push((branch, file, ReconcileOutcome::RoleExcluded)); continue; Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\sync.rs:647: b"\nREMOTE role", ) .unwrap(); - assert_eq!(cs.list_conflicts(&wt, Some("live-role.md")).unwrap().len(), 1); + assert_eq!( + cs.list_conflicts(&wt, Some("live-role.md")).unwrap().len(), + 1 + ); let report = SyncPullReport { applied: vec![ApplyReport { Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\sync.rs:671: "[adapter]\nname=\"mock\"\nversion=\"1\"\nmin_spt_core_version=\"1\"\n\n\ [session.psyche_resume]\ncommand='{cmd}'\n" ); - let rt = spt_runtime::ManifestRuntime::new( - spt_runtime::Manifest::from_toml_str(&toml).unwrap(), - ); + let rt = + spt_runtime::ManifestRuntime::new(spt_runtime::Manifest::from_toml_str(&toml).unwrap()); let outcomes = reconcile_after_sync( &rt, Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\translation.rs:113: _ => { // ctrl+: a control byte. `ctrl+s` → 0x13, `ctrl+space` → NUL, // `ctrl+[` → ESC, etc. Only single-char chords are mapped. - if let Some(rest) = lower.strip_prefix("ctrl+").or_else(|| lower.strip_prefix("c-")) { + if let Some(rest) = lower + .strip_prefix("ctrl+") + .or_else(|| lower.strip_prefix("c-")) + { return ctrl_byte(rest).map(|b| vec![b]); } // A single literal character → its own bytes (e.g. `{key:"y"}`). Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\translation.rs:265: } let mut child = command.spawn()?; let pid = child.id().into(); - let stdout = child - .stdout - .take() - .expect("stdout piped at spawn"); + let stdout = child.stdout.take().expect("stdout piped at spawn"); let stdin = child.stdin.take().expect("stdin piped at spawn"); let reader = thread::spawn(move || { let buf = BufReader::new(stdout); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\translation.rs:416: let (tx, _rx) = std::sync::mpsc::channel::(); match TranslationChild::spawn(&[prog.to_string()], tx) { Ok(child) => child.terminate(), // bounded no-zombie reap - Err(e) => panic!( - "CREATE_NO_WINDOW must not break the spawn (error-87 flag-combo class): {e}" - ), + Err(e) => { + panic!("CREATE_NO_WINDOW must not break the spawn (error-87 flag-combo class): {e}") + } } } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\translation.rs:429: fn key_cmd_parses_each_wire_shape() { assert_eq!( serde_json::from_str::(r#"{"key":"ctrl+s"}"#).unwrap(), - KeyCmd::Key { key: "ctrl+s".into() } + KeyCmd::Key { + key: "ctrl+s".into() + } ); assert_eq!( serde_json::from_str::(r#"{"text":"hello"}"#).unwrap(), Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\translation.rs:436: - KeyCmd::Text { text: "hello".into() } + KeyCmd::Text { + text: "hello".into() + } ); assert_eq!( serde_json::from_str::(r#"{"delay_ms":50}"#).unwrap(), Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\translation.rs:446: // forward-compat: an unknown field alongside a known shape still parses. assert_eq!( serde_json::from_str::(r#"{"key":"enter","repeat":3}"#).unwrap(), - KeyCmd::Key { key: "enter".into() } + KeyCmd::Key { + key: "enter".into() + } ); // a line matching no shape is an error. assert!(serde_json::from_str::(r#"{"bogus":1}"#).is_err()); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\translation.rs:471: // flush step 1 takes the buffered bytes (floor STAYS held) ... assert_eq!(f.take_or_release(), Some(b"hello".to_vec())); - assert!(f.is_held(), "floor stays held mid-flush so order is preserved"); + assert!( + f.is_held(), + "floor stays held mid-flush so order is preserved" + ); // ... input arriving mid-flush keeps buffering ... assert!(f.buffer_if_held(b"!"), "mid-flush input still buffers"); assert_eq!(f.take_or_release(), Some(b"!".to_vec())); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\translation.rs:478: // ... and the empty step RELEASES the floor. assert_eq!(f.take_or_release(), None); assert!(!f.is_held(), "drained empty → floor released"); - assert!(!f.buffer_if_held(b"z"), "released floor passes through again"); + assert!( + !f.buffer_if_held(b"z"), + "released floor passes through again" + ); } // [unit->REQ-MSG-IDLE-TRANSLATION-BINARY] the send-keys byte map: named keys, Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\translation.rs:494: assert_eq!(key_to_bytes("ctrl+s"), Some(vec![0x13])); assert_eq!(key_to_bytes("ctrl+a"), Some(vec![0x01])); assert_eq!(key_to_bytes("ctrl+b"), Some(vec![0x02])); // the rc detach byte - // arrows as xterm CSI. + // arrows as xterm CSI. assert_eq!(key_to_bytes("up"), Some(b"\x1b[A".to_vec())); assert_eq!(key_to_bytes("left"), Some(b"\x1b[D".to_vec())); // a single literal char passes through. Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\tunnelhub.rs:206: /// `token`. A second open (a relink) replaces the prior entry — the old stream /// ids are no longer referenced under the fresh token. // [impl->REQ-SHELL-4] - pub fn open(&self, owner: &str, shell_id: &str, token: &str, owner_stream: u64, shell_stream: u64) { + pub fn open( + &self, + owner: &str, + shell_id: &str, + token: &str, + owner_stream: u64, + shell_stream: u64, + ) { let mut map = self.map.lock().unwrap(); map.insert( slot_key(owner, shell_id), Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\tunnelhub.rs:270: /// dispatch change, no brain serve loop). Thread-per-connection (mirroring the /// digest / drive control channels). // [impl->REQ-SHELL-4] -pub fn serve_tunnel_control(name: &str, hub: Arc, broker: Arc) -> io::Result<()> { +pub fn serve_tunnel_control( + name: &str, + hub: Arc, + broker: Arc, +) -> io::Result<()> { let listener = LocalSocketTransport::bind(name)?; loop { let conn = listener.accept()?; Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\tunnelhub.rs:447: let env = read_frame(&mut conn)?; let res: TunnelRecvResult = serde_json::from_value(env.payload) .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?; - let bytes = decode_bytes(&res.data_b64) - .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?; + let bytes = + decode_bytes(&res.data_b64).map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?; Ok((bytes, res.finished)) } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\tunnelhub.rs:535: let hub = TunnelHub::new(); hub.open("doyle", "mock-shell-0", "old-token", 7, 8); hub.open("doyle", "mock-shell-0", "new-token", 11, 12); - assert_eq!(hub.owner_stream("doyle", "mock-shell-0", "new-token"), Some(11)); - assert_eq!(hub.shell_stream("doyle", "mock-shell-0", "new-token"), Some(12)); + assert_eq!( + hub.owner_stream("doyle", "mock-shell-0", "new-token"), + Some(11) + ); + assert_eq!( + hub.shell_stream("doyle", "mock-shell-0", "new-token"), + Some(12) + ); assert_eq!(hub.owner_stream("doyle", "mock-shell-0", "old-token"), None); } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\wan.rs:312: // broker's dispatch_endpoint_input). // [impl->REQ-WAN-SPT-HOSTED-DELIVERY] // [impl->REQ-HAZARD-DELIVERY-STARVATION] - if let Some((true, _)) = - crate::inject::try_spt_hosted_inject(&msg.target, &delivered_from, &delivered_body, owlery, false) - { + if let Some((true, _)) = crate::inject::try_spt_hosted_inject( + &msg.target, + &delivered_from, + &delivered_body, + owlery, + false, + ) { let _ = spool::wan_mark_seen_at(&perch_path, &msg.op_id); return WanOutcome::DeliveredInject; } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\wan.rs:341: // Empty from → the origin node's display (node_label_display(origin, None)) — // never blank, and it identifies the QUIC-proven origin node. let rendered = render_delivered_from("", origin); - assert!(!rendered.is_empty(), "an empty from must NEVER render blank"); + assert!( + !rendered.is_empty(), + "an empty from must NEVER render blank" + ); assert_eq!(rendered, node_label_display(origin, None)); // A non-empty from is untouched (the identity gate + reply routing keep it). assert_eq!(render_delivered_from("peer-x", origin), "peer-x"); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\wan.rs:348: - assert_eq!(render_delivered_from("cli@ENLYZEAM", origin), "cli@ENLYZEAM"); + assert_eq!( + render_delivered_from("cli@ENLYZEAM", origin), + "cli@ENLYZEAM" + ); } // [unit->REQ-WAN-SEND-DELIVERY] the reply-leg token vocabulary round-trips: Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\wan.rs:374: WanRequestOutcome::from_token("some_future_verb"), WanRequestOutcome::NoReply ); - assert_eq!(WanRequestOutcome::from_token(""), WanRequestOutcome::NoReply); + assert_eq!( + WanRequestOutcome::from_token(""), + WanRequestOutcome::NoReply + ); } // [unit->REQ-MSG-5] WAN-ingress re-stamp (KH 7.5): a user-msg body from an Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\wan.rs:434: let proven = "aa11node"; // (1) Gateway-typed, hosted on the proven node → honored. - assert!(origin_user_backed(&[row(proven, Some(GATEWAY_TAG))], proven)); + assert!(origin_user_backed( + &[row(proven, Some(GATEWAY_TAG))], + proven + )); // (2) A non-Gateway (agent / other) type → re-stamped. - assert!(!origin_user_backed(&[row(proven, Some("live_agent"))], proven)); - assert!(!origin_user_backed(&[row(proven, Some("ready_agent"))], proven)); + assert!(!origin_user_backed( + &[row(proven, Some("live_agent"))], + proven + )); + assert!(!origin_user_backed( + &[row(proven, Some("ready_agent"))], + proven + )); // (3) No endpoint_type advertised (an N-1 node) → re-stamped (rollout grace). assert!(!origin_user_backed(&[row(proven, None)], proven)); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\src\wan.rs:445: // (4) A Gateway row exists, but on a DIFFERENT node than the proven // origin — keying is on the proven node, never the wire `from`. - assert!(!origin_user_backed(&[row("bb22other", Some(GATEWAY_TAG))], proven)); + assert!(!origin_user_backed( + &[row("bb22other", Some(GATEWAY_TAG))], + proven + )); // …and a mix where the proven node is agent-typed while another node is // the gateway → still re-stamped (the proven node's own type governs). Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\access.rs:17: use spt_daemon::access::note_outbound; use spt_daemon::brain::{Brain, BrokerEvent}; -use spt_daemon::effect::{Minter, MintedOp}; +use spt_daemon::effect::{MintedOp, Minter}; use spt_daemon::nethost::{NetConfig, NetHost}; use spt_daemon::registryhost::RegistryHost; use spt_daemon::wan::{receive_wan, WanOutcome}; Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\access.rs:175: .expect("node id"); let mut receiver = connect_retry(&name_b); let addr = receiver.net_status().expect("b status").addr; - let conn = sender.net_dial(addr, Some(MintedOp::new(Minter::Cli, 1))).expect("dial"); - let opened = sender.net_open_stream(conn.conn_id, Some(MintedOp::new(Minter::Cli, 2))).expect("open"); + let conn = sender + .net_dial(addr, Some(MintedOp::new(Minter::Cli, 1))) + .expect("dial"); + let opened = sender + .net_open_stream(conn.conn_id, Some(MintedOp::new(Minter::Cli, 2))) + .expect("open"); // (1) Unsolicited from a non-listed node → refused at the gate, no spool. // (Sent before the stream-wait: a QUIC bidi stream only becomes visible to Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\access.rs:183: // the acceptor once bytes flow.) let m1 = msg(&target, "let me in", "a:1"); sender - .net_stream_send(opened.stream_id, &m1.encode_line(), Some(MintedOp::new(Minter::Cli, 100)), false) + .net_stream_send( + opened.stream_id, + &m1.encode_line(), + Some(MintedOp::new(Minter::Cli, 100)), + false, + ) .expect("send 1"); let (stream, origin) = wait_for_stream(&mut receiver); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\access.rs:194: receiver.net_stream_subscribe(stream, 0).expect("subscribe"); let mut decoder = WanDecoder::new(); assert_eq!( - funnel_one(&mut receiver, stream, &mut decoder, &origin, &owlery, ®istry), + funnel_one( + &mut receiver, + stream, + &mut decoder, + &origin, + &owlery, + ®istry + ), WanOutcome::Refused, "non-listed unsolicited refused" ); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\access.rs:209: note_outbound(&target, &a_node, now_ms()); let m2 = msg(&target, "re: your message", "a:2"); sender - .net_stream_send(opened.stream_id, &m2.encode_line(), Some(MintedOp::new(Minter::Cli, 101)), false) + .net_stream_send( + opened.stream_id, + &m2.encode_line(), + Some(MintedOp::new(Minter::Cli, 101)), + false, + ) .expect("send 2"); assert_eq!( - funnel_one(&mut receiver, stream, &mut decoder, &origin, &owlery, ®istry), + funnel_one( + &mut receiver, + stream, + &mut decoder, + &origin, + &owlery, + ®istry + ), WanOutcome::Spooled, "correlated reply exempt from the whitelist" ); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\access.rs:224: store.save().expect("save access store"); let m3 = msg(&target, "hello again, listed now", "a:3"); sender - .net_stream_send(opened.stream_id, &m3.encode_line(), Some(MintedOp::new(Minter::Cli, 102)), true) + .net_stream_send( + opened.stream_id, + &m3.encode_line(), + Some(MintedOp::new(Minter::Cli, 102)), + true, + ) .expect("send 3"); assert_eq!( - funnel_one(&mut receiver, stream, &mut decoder, &origin, &owlery, ®istry), + funnel_one( + &mut receiver, + stream, + &mut decoder, + &origin, + &owlery, + ®istry + ), WanOutcome::Spooled, "whitelisted node admitted" ); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\attach.rs:32: #[cfg(unix)] use spt_daemon::attach::request_attach_endpoint; use spt_daemon::brain::{Brain, BrainState, BrokerEvent}; -use spt_daemon::effect::{Minter, MintedOp}; +use spt_daemon::effect::{MintedOp, Minter}; use spt_daemon::msg::{decode_bytes, SpawnReq}; use spt_daemon::nethost::{NetConfig, NetHost}; use spt_daemon::Broker; Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\attach.rs:152: expected_origin: &str, marker: &[u8], ) -> (Vec, Brain) { - let stream_b = request_attach(operator, conn_id, session_id, 0, MintedOp::new(Minter::Rc, 2), AttachIntent::Control).expect("request"); + let stream_b = request_attach( + operator, + conn_id, + session_id, + 0, + MintedOp::new(Minter::Rc, 2), + AttachIntent::Control, + ) + .expect("request"); operator .net_stream_subscribe(stream_b, 0) .expect("operator subscribe"); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\attach.rs:168: let endpoint_owned = endpoint.to_string(); let broker_owned = target_broker.to_string(); let server = thread::spawn(move || { - let outcome = - serve_attach(&mut target, &broker_owned, stream_a, &endpoint_owned, &origin, 0, None) - .expect("serve"); + let outcome = serve_attach( + &mut target, + &broker_owned, + stream_a, + &endpoint_owned, + &origin, + 0, + None, + ) + .expect("serve"); (outcome, target) }); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\attach.rs:328: .expect("b status") .node_id_hex .expect("node id"); - let conn = operator.net_dial(a_addr, Some(MintedOp::new(Minter::Cli, 1))).expect("dial A"); - let stream_b = - request_attach(&mut operator, conn.conn_id, spawned.session_id, 0, MintedOp::new(Minter::Rc, 2), AttachIntent::Control).expect("request"); + let conn = operator + .net_dial(a_addr, Some(MintedOp::new(Minter::Cli, 1))) + .expect("dial A"); + let stream_b = request_attach( + &mut operator, + conn.conn_id, + spawned.session_id, + 0, + MintedOp::new(Minter::Rc, 2), + AttachIntent::Control, + ) + .expect("request"); operator .net_stream_subscribe(stream_b, 0) .expect("operator subscribe"); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\attach.rs:337: // A serves the inbound attach stream (endpoint = the brought-up id). let (stream_a, origin) = wait_for_stream(&mut target); - assert_eq!(origin, b_node, "serve gate subject is the handshake identity"); + assert_eq!( + origin, b_node, + "serve gate subject is the handshake identity" + ); let serve_broker = name_a.clone(); let server = thread::spawn(move || { - let outcome = - serve_attach(&mut target, &serve_broker, stream_a, "cc-ep", &origin, 0, None).expect("serve"); + let outcome = serve_attach( + &mut target, + &serve_broker, + stream_a, + "cc-ep", + &origin, + 0, + None, + ) + .expect("serve"); (outcome, target) }); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\attach.rs:395: .expect("b status") .node_id_hex .expect("node id"); - let conn = operator.net_dial(a_addr, Some(MintedOp::new(Minter::Cli, 1))).expect("dial"); + let conn = operator + .net_dial(a_addr, Some(MintedOp::new(Minter::Cli, 1))) + .expect("dial"); let (_viewport, mut target) = attach_drive_detach( &mut operator, &name_a, Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\attach.rs:445: // this node's OWN broker-minted id — the origin the peer row carries and the // serve gates same-node against. let mut operator = connect_retry(&name); - let dialed = operator.net_dial_loopback().expect("operator loopback dial"); + let dialed = operator + .net_dial_loopback() + .expect("operator loopback dial"); let own_origin = dialed.remote_id_hex.clone(); let (_viewport, mut target) = attach_drive_detach( &mut operator, Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\attach.rs:549: assert_eq!(origin, own_origin); let serve_broker = name.clone(); let server = thread::spawn(move || { - serve_attach(&mut target, &serve_broker, stream_a, "burst-ep", &origin, 0, None).expect("serve") + serve_attach( + &mut target, + &serve_broker, + stream_a, + "burst-ep", + &origin, + 0, + None, + ) + .expect("serve") }); // The operator must RENDER the full pre-populated ring through the LAST marker. Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\attach.rs:656: // the wire's placeholder session_id (0). Passing it here exercises the // endpoint-resolved cross-node serve path (not the local wire-session path). let server = thread::spawn(move || { - serve_attach(&mut target, &serve_broker, stream_a, "altep", &origin, 0, Some(sid)) - .expect("serve") + serve_attach( + &mut target, + &serve_broker, + stream_a, + "altep", + &origin, + 0, + Some(sid), + ) + .expect("serve") }); // Render the operator's received bytes; the repaint must carry the alt viewport. Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\attach.rs:791: let a_addr = life1.net_status().expect("a status").addr; let mut operator = connect_retry(&name_b); - let conn = operator.net_dial(a_addr, Some(MintedOp::new(Minter::Cli, 1))).expect("dial"); - let stream_b = request_attach(&mut operator, conn.conn_id, sid, 0, MintedOp::new(Minter::Rc, 2), AttachIntent::Control).expect("request"); + let conn = operator + .net_dial(a_addr, Some(MintedOp::new(Minter::Cli, 1))) + .expect("dial"); + let stream_b = request_attach( + &mut operator, + conn.conn_id, + sid, + 0, + MintedOp::new(Minter::Rc, 2), + AttachIntent::Control, + ) + .expect("request"); operator .net_stream_subscribe(stream_b, 0) .expect("operator subscribe"); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\attach.rs:823: } AttachRecord::Input { data_b64, op_id } => { let b = decode_bytes(&data_b64).expect("b64"); - life1.send_effect(MintedOp::new(Minter::Rc, op_id), &b).expect("journaled input"); + life1 + .send_effect(MintedOp::new(Minter::Rc, op_id), &b) + .expect("journaled input"); } _ => {} } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\attach.rs:862: let origin2 = origin.clone(); let serve_broker = name_a.clone(); let server = thread::spawn(move || { - let outcome = serve_attach(&mut life2, &serve_broker, stream_a, "ling", &origin2, 0, None) - .expect("re-serve"); + let outcome = serve_attach( + &mut life2, + &serve_broker, + stream_a, + "ling", + &origin2, + 0, + None, + ) + .expect("re-serve"); (outcome, life2) }); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\attach.rs:968: .expect("b status") .node_id_hex .expect("node id"); - let conn = operator.net_dial(a_addr, Some(MintedOp::new(Minter::Cli, 1))).expect("dial"); - let stream_b = request_attach(&mut operator, conn.conn_id, sid, 0, MintedOp::new(Minter::Rc, 2), AttachIntent::Control).expect("request"); + let conn = operator + .net_dial(a_addr, Some(MintedOp::new(Minter::Cli, 1))) + .expect("dial"); + let stream_b = request_attach( + &mut operator, + conn.conn_id, + sid, + 0, + MintedOp::new(Minter::Rc, 2), + AttachIntent::Control, + ) + .expect("request"); operator .net_stream_subscribe(stream_b, 0) .expect("operator subscribe"); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\attach.rs:978: let endpoint_serve = endpoint.clone(); let serve_broker = name_a.clone(); let server = thread::spawn(move || { - let outcome = - serve_attach(&mut target, &serve_broker, stream_a, &endpoint_serve, &origin, 0, None) - .expect("serve"); + let outcome = serve_attach( + &mut target, + &serve_broker, + stream_a, + &endpoint_serve, + &origin, + 0, + None, + ) + .expect("serve"); (outcome, target) }); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\attach.rs:1026: std::thread::sleep(std::time::Duration::from_millis(10)); false }); - assert!(cleared, "viewport over → marker cleared (broker re-stamps None)"); + assert!( + cleared, + "viewport over → marker cleared (broker re-stamps None)" + ); target.kill_session().expect("cleanup kill"); } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\attach.rs:1078: // Operator A drives an (undriven) endpoint → controller. let mut a = connect_retry(&name); - a.attach_as(sid, 0, AttachIntent::Control, Some("node-A")).expect("A control"); - assert_eq!(read_outcome(&mut a), SubscribeOutcome::Controller, "free → controller"); + a.attach_as(sid, 0, AttachIntent::Control, Some("node-A")) + .expect("A control"); + assert_eq!( + read_outcome(&mut a), + SubscribeOutcome::Controller, + "free → controller" + ); // Operator B's plain Control hits a CONTROLLED endpoint → busy-refuse, NOT a // silent displace (gate #4). A is untouched. Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\attach.rs:1086: let mut b = connect_retry(&name); - b.attach_as(sid, 0, AttachIntent::Control, Some("node-B")).expect("B control"); + b.attach_as(sid, 0, AttachIntent::Control, Some("node-B")) + .expect("B control"); assert_eq!( read_outcome(&mut b), - SubscribeOutcome::BusyControlled { by: "node-A".to_string() }, + SubscribeOutcome::BusyControlled { + by: "node-A".to_string() + }, "controlled → busy-refuse with the controller's identity" ); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\attach.rs:1094: // A viewer coexists (read-only; never displaces). let mut v = connect_retry(&name); - v.attach_as(sid, 0, AttachIntent::Viewer, Some("node-V")).expect("V view"); - assert_eq!(read_outcome(&mut v), SubscribeOutcome::Viewer, "viewer attaches"); + v.attach_as(sid, 0, AttachIntent::Viewer, Some("node-V")) + .expect("V view"); + assert_eq!( + read_outcome(&mut v), + SubscribeOutcome::Viewer, + "viewer attaches" + ); // B's explicit Take displaces A: A gets a LOUD Displaced{by:node-B}, B becomes // controller. This is the ONLY displace path. Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\attach.rs:1101: - b.attach_as(sid, 0, AttachIntent::Take, Some("node-B")).expect("B take"); - assert_eq!(read_outcome(&mut b), SubscribeOutcome::TookControl, "take → took control"); + b.attach_as(sid, 0, AttachIntent::Take, Some("node-B")) + .expect("B take"); + assert_eq!( + read_outcome(&mut b), + SubscribeOutcome::TookControl, + "take → took control" + ); let displaced = (0..2000).find_map(|_| match a.read_event().expect("A event") { BrokerEvent::Displaced { by, .. } => Some(by), _ => None, Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\attach.rs:1106: }); - assert_eq!(displaced.as_deref(), Some("node-B"), "A receives the loud kick notice"); + assert_eq!( + displaced.as_deref(), + Some("node-B"), + "A receives the loud kick notice" + ); } // [int->REQ-RCVIEW-1] GATE #7 (the self-kick trap): a SAME-origin re-subscribe — Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\attach.rs:1121: // a BOUNDED read to assert the absence of a Displaced frame. let mut first = Brain::cold_start_pump(&name, 1, Duration::from_secs(5)).expect("first pump conn"); - first.attach_as(sid, 0, AttachIntent::Control, Some("node-A")).expect("first control"); + first + .attach_as(sid, 0, AttachIntent::Control, Some("node-A")) + .expect("first control"); assert_eq!(read_outcome(&mut first), SubscribeOutcome::Controller); // The "successor" re-serves the SAME operator's stream (same by) on a new Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\attach.rs:1128: // connection — the brain-restart re-take. let mut successor = connect_retry(&name); - successor.attach_as(sid, 0, AttachIntent::Control, Some("node-A")).expect("successor control"); + successor + .attach_as(sid, 0, AttachIntent::Control, Some("node-A")) + .expect("successor control"); assert_eq!( read_outcome(&mut successor), SubscribeOutcome::Controller, Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\attach.rs:1137: // The first connection must NOT receive a Displaced — re-taking your own slot // is never a kick. Drive a marker through the successor and confirm `first` // saw no Displaced in the window. - successor.send_effect(MintedOp::new(Minter::Rc, 7), b"GATE7\r").expect("drive"); + successor + .send_effect(MintedOp::new(Minter::Rc, 7), b"GATE7\r") + .expect("drive"); let mut saw_displaced = false; for _ in 0..50 { // Non-fatal drain: the first conn may see nothing at all (it was silently Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\attach.rs:1151: Err(_) => break, // timeout — nothing pending } } - assert!(!saw_displaced, "a same-origin re-take must never kick the prior holder (gate #7)"); + assert!( + !saw_displaced, + "a same-origin re-take must never kick the prior holder (gate #7)" + ); } // [int->REQ-RCVIEW-1] Resize is CONTROLLER-EXCLUSIVE: a resize arriving on a Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\attach.rs:1167: // conn blocks forever when nothing is incoming (hung the Linux runner: `cat` // emits nothing on resize, unlike Windows `findstr`). let mut ctrl = Brain::cold_start_pump(&name, 1, Duration::from_secs(5)).expect("ctrl conn"); - ctrl.attach_as(sid, 0, AttachIntent::Control, Some("node-A")).expect("control"); + ctrl.attach_as(sid, 0, AttachIntent::Control, Some("node-A")) + .expect("control"); assert_eq!(read_outcome(&mut ctrl), SubscribeOutcome::Controller); let mut view = Brain::cold_start_pump(&name, 1, Duration::from_secs(5)).expect("view conn"); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\attach.rs:1174: - view.attach_as(sid, 0, AttachIntent::Viewer, Some("node-V")).expect("view"); + view.attach_as(sid, 0, AttachIntent::Viewer, Some("node-V")) + .expect("view"); assert_eq!(read_outcome(&mut view), SubscribeOutcome::Viewer); // The viewer's resize is rejected (it is not the controller). Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\attach.rs:1183: } }); assert!( - refused.as_deref().is_some_and(|m| m.contains("controller-exclusive")), + refused + .as_deref() + .is_some_and(|m| m.contains("controller-exclusive")), "a viewer's resize is refused as controller-exclusive, got {refused:?}" ); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\attach.rs:1190: // The controller's resize is honored (no error). ctrl.resize(50, 100).expect("controller resize"); - let ctrl_err = ctrl.read_event_until(Some(std::time::Instant::now() + Duration::from_millis(50))); + let ctrl_err = + ctrl.read_event_until(Some(std::time::Instant::now() + Duration::from_millis(50))); assert!( !matches!(ctrl_err, Ok(BrokerEvent::Error { .. })), "the controller's resize is honored" Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\attach.rs:1232: let (_broker, name, _spawner, sid) = labeled_session("cv-isolation"); let mut ctrl = connect_retry(&name); - ctrl.attach_as(sid, 0, AttachIntent::Control, Some("node-A")).expect("control"); + ctrl.attach_as(sid, 0, AttachIntent::Control, Some("node-A")) + .expect("control"); assert_eq!(read_outcome(&mut ctrl), SubscribeOutcome::Controller); // A viewer attaches but then NEVER reads — its writer thread blocks on the Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\attach.rs:1239: // socket, its bounded queue fills, and the drain evicts it. let mut view = connect_retry(&name); - view.attach_as(sid, 0, AttachIntent::Viewer, Some("node-V")).expect("view"); + view.attach_as(sid, 0, AttachIntent::Viewer, Some("node-V")) + .expect("view"); assert_eq!(read_outcome(&mut view), SubscribeOutcome::Viewer); // (deliberately drop the read side: `view` is never polled again) Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\attach.rs:1245: // A big burst echoed by the child overflows the wedged viewer; a trailing // marker proves the controller's stream kept flowing. let big = vec![b'x'; 200_000]; - ctrl.send_effect(MintedOp::new(Minter::Rc, 1), &big).expect("burst"); - ctrl.send_effect(MintedOp::new(Minter::Rc, 2), b"\rISOLATED\r").expect("marker"); + ctrl.send_effect(MintedOp::new(Minter::Rc, 1), &big) + .expect("burst"); + ctrl.send_effect(MintedOp::new(Minter::Rc, 2), b"\rISOLATED\r") + .expect("marker"); let mut got = Vec::new(); let mut irrecoverable = false; Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\attach.rs:1265: // outcome, NOT a hang and NOT the wedged viewer's stall propagating. This // proves VIEWER-ISOLATION exactly as much as rendering ISOLATED does, so // accept it (do NOT .expect()-panic on the irrecoverable marker). - Err(e) if e.get_ref().is_some_and(|i| i.is::()) => { + Err(e) + if e.get_ref() + .is_some_and(|i| i.is::()) => + { irrecoverable = true; break; } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\attach.rs:1299: } } Ok(BrokerEvent::Displaced { .. }) => panic!("a viewer must NEVER receive Displaced"), - Ok(_) => continue, // Size / other — keep reading - Err(_) => continue, // slice timeout — keep waiting until the deadline + Ok(_) => continue, // Size / other — keep reading + Err(_) => continue, // slice timeout — keep waiting until the deadline } } false Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\attach.rs:1318: // Controller on a pump conn (so a bounded read is possible). let mut ctrl = Brain::cold_start_pump(&name, 1, Duration::from_secs(5)).expect("ctrl conn"); - ctrl.attach_as(sid, 0, AttachIntent::Control, Some("node-A")).expect("ctrl control"); + ctrl.attach_as(sid, 0, AttachIntent::Control, Some("node-A")) + .expect("ctrl control"); assert_eq!(read_outcome(&mut ctrl), SubscribeOutcome::Controller); // Viewer attached BEFORE the crash (pump conn). Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\attach.rs:1325: let mut view = Brain::cold_start_pump(&name, 1, Duration::from_secs(5)).expect("view conn"); - view.attach_as(sid, 0, AttachIntent::Viewer, Some("node-V")).expect("view"); + view.attach_as(sid, 0, AttachIntent::Viewer, Some("node-V")) + .expect("view"); assert_eq!(read_outcome(&mut view), SubscribeOutcome::Viewer); // The viewer renders pre-crash output (it is genuinely live). Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\attach.rs:1330: - ctrl.send_effect(MintedOp::new(Minter::Rc, 1), b"BEFORE\r").expect("before marker"); + ctrl.send_effect(MintedOp::new(Minter::Rc, 1), b"BEFORE\r") + .expect("before marker"); assert!( viewer_reads_marker_no_displace(&mut view, b"BEFORE"), "viewer renders pre-restart output" Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\attach.rs:1341: // re-take. It silently becomes controller (NEVER displacing anyone): the // gate-#7 self-kick guard on a real controller-conn restart. let mut succ = Brain::cold_start_pump(&name, 2, Duration::from_secs(5)).expect("succ conn"); - succ.attach_as(sid, 0, AttachIntent::Control, Some("node-A")).expect("succ control"); + succ.attach_as(sid, 0, AttachIntent::Control, Some("node-A")) + .expect("succ control"); assert_eq!( read_outcome(&mut succ), SubscribeOutcome::Controller, Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\attach.rs:1350: // The viewer SURVIVED the controller restart: output driven by the successor // reaches it, and it NEVER saw a Displaced. - succ.send_effect(MintedOp::new(Minter::Rc, 2), b"AFTER\r").expect("after marker"); + succ.send_effect(MintedOp::new(Minter::Rc, 2), b"AFTER\r") + .expect("after marker"); assert!( viewer_reads_marker_no_displace(&mut view, b"AFTER"), "viewer survives the controller restart and keeps receiving (no Displaced)" Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\attach.rs:1394: // CONSUMPTION cursor, not the successor connection's delivered state). let mut driver = connect_retry(&name); let sid = driver.spawn_session(echo_spawn_req()).expect("spawn echo"); - driver.send_effect(MintedOp::new(Minter::Rc, 1), b"SEED_ONE\r").expect("seed input"); + driver + .send_effect(MintedOp::new(Minter::Rc, 1), b"SEED_ONE\r") + .expect("seed input"); // Read one Output event to advance the driver's next_seq to 1. loop { match driver.read_event().expect("driver event") { Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\attach.rs:1439: ); // The local resume bookkeeping matches the snapshot (generation bumped, the // session carried, the cursor rehydrated) alongside the resume subscribe. - assert_eq!(succ.session_id(), Some(sid), "the carried session id is set"); assert_eq!( + succ.session_id(), + Some(sid), + "the carried session id is set" + ); + assert_eq!( succ.next_seq(), prior_next_seq, "the legacy resume cursor is rehydrated from the snapshot" Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\attach.rs:1489: // non-trivial (>0): K==0 could not distinguish a reset-to-0 from no reset. let mut driver = connect_retry(&name); let sid = driver.spawn_session(echo_spawn_req()).expect("spawn echo"); - driver.send_effect(MintedOp::new(Minter::Rc, 1), b"SEED\r").expect("seed input"); + driver + .send_effect(MintedOp::new(Minter::Rc, 1), b"SEED\r") + .expect("seed input"); loop { match driver.read_event().expect("driver event") { BrokerEvent::Output { .. } => break, Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\attach.rs:1501: assert!(k >= 1, "driver must consume >= seq 0 so K>0 (got {k})"); // Produce a dead-window frame at/after seq K the driver never reads — the // successor will replay it (the frame the handoff reader consumes pre-attach). - driver.send_effect(MintedOp::new(Minter::Rc, 2), b"DEADWIN\r").expect("dead-window input"); + driver + .send_effect(MintedOp::new(Minter::Rc, 2), b"DEADWIN\r") + .expect("dead-window input"); let state = driver.snapshot(); - assert_eq!(state.next_seq, k, "snapshot carries the consumption cursor K"); + assert_eq!( + state.next_seq, k, + "snapshot carries the consumption cursor K" + ); drop(driver); // The successor handoff seeds its dedup cursor at K (resume mode). Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\attach.rs:1510: let mut succ = Brain::handoff(&name, state, 2).expect("handoff"); - assert_eq!(succ.session_cursor(sid), Some(k), "handoff seeds the resume cursor at K"); + assert_eq!( + succ.session_cursor(sid), + Some(k), + "handoff seeds the resume cursor at K" + ); // THE PRE-ATTACHED CONSUME, forced deterministically: read the dead-window // frame (the first seq >= K) on the successor. This is what `serve_attach` Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\attach.rs:1520: _ => {} } }; - assert!(consumed >= k, "the successor consumed the first frame at/after K (got {consumed}, K={k})"); - let advanced = succ.session_cursor(sid).expect("cursor present after a consume"); + assert!( + consumed >= k, + "the successor consumed the first frame at/after K (got {consumed}, K={k})" + ); + let advanced = succ + .session_cursor(sid) + .expect("cursor present after a consume"); assert!( advanced > k, "the pre-attached consume advanced the dedup cursor past K (cursor={advanced}, K={k})" Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\brain_decouple.rs:59: use spt_daemon::codec::{read_frame, write_frame}; use spt_daemon::frame::{Envelope, Role}; use spt_daemon::msg::{ - SpawnReq, Spawned, StallEvictsReply, SubscribeOutcome, SubscribeReq, SubscribedReply, KIND_SPAWN, - KIND_SPAWNED, KIND_STALL_EVICTS, KIND_STALL_EVICTS_REPLY, KIND_SUBSCRIBE, KIND_SUBSCRIBED, + SpawnReq, Spawned, StallEvictsReply, SubscribeOutcome, SubscribeReq, SubscribedReply, + KIND_SPAWN, KIND_SPAWNED, KIND_STALL_EVICTS, KIND_STALL_EVICTS_REPLY, KIND_SUBSCRIBE, + KIND_SUBSCRIBED, }; use spt_daemon::transport::{send_hello, LocalSocketTransport}; use spt_daemon::Broker; Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\brain_decouple.rs:245: let sid = loop { let f = read_frame(&mut a).expect("frame before spawned"); if f.kind == KIND_SPAWNED { - break serde_json::from_value::(f.payload).unwrap().session_id; + break serde_json::from_value::(f.payload) + .unwrap() + .session_id; } }; Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\broker.rs:345: #[cfg(unix)] let (program, args) = ( "sh".to_string(), - vec!["-c".to_string(), "echo ENVCHECK=$SPT_ENDPOINT_ID".to_string()], + vec![ + "-c".to_string(), + "echo ENVCHECK=$SPT_ENDPOINT_ID".to_string(), + ], ); #[cfg(windows)] let (program, args) = ( Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\broker.rs:352: "cmd".to_string(), - vec!["/c".to_string(), "echo ENVCHECK=%SPT_ENDPOINT_ID%".to_string()], + vec![ + "/c".to_string(), + "echo ENVCHECK=%SPT_ENDPOINT_ID%".to_string(), + ], ); let mut env = std::collections::BTreeMap::new(); env.insert("SPT_ENDPOINT_ID".to_string(), "wall-b".to_string()); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\broker.rs:452: // A child that exits immediately. #[cfg(unix)] - let (program, args) = ("sh".to_string(), vec!["-c".to_string(), "exit 0".to_string()]); + let (program, args) = ( + "sh".to_string(), + vec!["-c".to_string(), "exit 0".to_string()], + ); #[cfg(windows)] - let (program, args) = ("cmd".to_string(), vec!["/c".to_string(), "exit".to_string()]); + let (program, args) = ( + "cmd".to_string(), + vec!["/c".to_string(), "exit".to_string()], + ); send( &mut conn, KIND_SPAWN, Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\broker.rs:476: for _ in 0..200 { match read_frame(&mut conn) { Ok(f) if f.kind == KIND_SPAWNED => { - sid = Some(serde_json::from_value::(f.payload).unwrap().session_id); + sid = Some( + serde_json::from_value::(f.payload) + .unwrap() + .session_id, + ); break; } Ok(_) => {} Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\broker.rs:580: [env.SPT_ENDPOINT_ID]\ndirection = \"inject\"\nvalue = \"{{id}}\"\n" ); let manifest = spt_runtime::Manifest::from_toml_str(&manifest_toml).unwrap(); - let prepared = - spt_daemon::harnesshost::prepare_harness_spawn( - "wall-b", "mock", "sid-1", &manifest, false, None, None, - ) - .expect("prepare"); + let prepared = spt_daemon::harnesshost::prepare_harness_spawn( + "wall-b", "mock", "sid-1", &manifest, false, None, None, + ) + .expect("prepare"); // F-013: the id is filled into the env value (not empty). assert_eq!( prepared.env.get("SPT_ENDPOINT_ID").map(String::as_str), Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\broker.rs:708: /// Spawn the long-lived echo child and return its session id (draining any /// interleaved early output into `out`). fn spawn_echo(conn: &mut Stream, out: &mut Vec) -> u64 { - send(conn, KIND_SPAWN, serde_json::to_value(echo_spawn_req()).unwrap()); + send( + conn, + KIND_SPAWN, + serde_json::to_value(echo_spawn_req()).unwrap(), + ); loop { let f = read_frame(conn).expect("frame before spawned"); match f.kind.as_str() { Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\broker.rs:1030: let sid = loop { let f = read_frame(&mut conn).expect("frame before spawned"); if f.kind == KIND_SPAWNED { - break serde_json::from_value::(f.payload).unwrap().session_id; + break serde_json::from_value::(f.payload) + .unwrap() + .session_id; } }; Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\broker.rs:1100: } } } - let last_live_seq = *dedup.accepted_seqs.last().expect("at least one chunk accepted"); + let last_live_seq = *dedup + .accepted_seqs + .last() + .expect("at least one chunk accepted"); assert!( last_live_seq >= 1, "the ring must hold at least seqs 0 and 1 before the double-subscribe \ Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\broker.rs:1206: } fn contains(haystack: &[u8], needle: &[u8]) -> bool { - haystack - .windows(needle.len()) - .any(|w| w == needle) + haystack.windows(needle.len()).any(|w| w == needle) } // [int->REQ-HAZARD-CONTROLLER-WRITER-REORDER] Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\control_stamp_lifetime.rs:178: Some(2), "precondition: viewer_count latched Some(2) before reap" ); - assert!(latched.controlled, "precondition: controlled true before reap"); + assert!( + latched.controlled, + "precondition: controlled true before reap" + ); // ── Kill the PTY CHILD → the exit-waiter reaps the session (NOT a conn drop, so // the controller-detach path never runs; only the reap path can unlatch). ── Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\control_stamp_lifetime.rs:351: let online_id = format!("b3-online-{pid}"); // Arm B: already-OFFLINE + sticky (survived a daemon restart — the boot sweep). let offline_id = format!("b3-boot-{pid}"); - let online_perch = seed_sticky_hosted_perch(&online_id, spt_store::liveness::STATUS_ONLINE, node); + let online_perch = + seed_sticky_hosted_perch(&online_id, spt_store::liveness::STATUS_ONLINE, node); let offline_perch = seed_sticky_hosted_perch(&offline_id, spt_store::liveness::STATUS_OFFLINE, node); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\control_stamp_lifetime.rs:398: eprintln!( "=== F028 B3 REAP: online[controlled={} driven_by={:?} status={:?}] \ boot[controlled={} driven_by={:?} status={:?}] offlined={offlined:?} ===", - after_online.controlled, after_online.driven_by, after_online.status, - after_offline.controlled, after_offline.driven_by, after_offline.status, + after_online.controlled, + after_online.driven_by, + after_online.status, + after_offline.controlled, + after_offline.driven_by, + after_offline.status, ); // ── Reap scoped (decoy child + spawner). ── Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\daemon_lifecycle_real_brain.rs:66: let id = "agent9"; let perch_path = perch::resolve_perch_path(id, ParentHint::Infer); std::fs::create_dir_all(&perch_path).unwrap(); - let mut rec = spt_store::info::InfoJson::new(id, "t", std::process::id(), "sid-9", "live_agent"); + let mut rec = + spt_store::info::InfoJson::new(id, "t", std::process::id(), "sid-9", "live_agent"); rec.adapter = Some("mock".to_string()); spt_store::info::write_info(&perch_path, &rec).unwrap(); spt_store::info::set_status(&perch_path, STATUS_ONLINE).unwrap(); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\digest.rs:31: static SEQ: AtomicU32 = AtomicU32::new(0); fn unique(prefix: &str) -> String { let n = SEQ.fetch_add(1, Ordering::Relaxed); - format!("spt-daemon-digest-{prefix}-{}-{}.sock", std::process::id(), n) + format!( + "spt-daemon-digest-{prefix}-{}-{}.sock", + std::process::id(), + n + ) } /// A stdin pass-through "extractor": the source bytes (piped in) round-trip to Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\digest.rs:57: PASSTHROUGH, fixture.display(), ); - let src = perch::spt_home().join("srcs").join(format!("{adapter}-src")); + let src = perch::spt_home() + .join("srcs") + .join(format!("{adapter}-src")); std::fs::create_dir_all(&src).unwrap(); std::fs::write(src.join("manifest.toml"), manifest).unwrap(); spt_runtime::registry::register(&perch::adapters_dir(), &src, 1000).unwrap(); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\digest.rs:118: pull_snapshot(&digest_name, "cc", DigestOverride::default()) }) .expect("pull ok") - .expect("a digest projects for the harness-hosted endpoint"); + .expect("a digest projects for the harness-hosted endpoint"); assert!(version >= 1, "the projection has a version"); assert_eq!(digest.turns.len(), 1, "one user turn: {digest:?}"); assert_eq!(digest.turns[0].input.as_deref(), Some("add a file")); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\digest.rs:174: reproject(&digest_name, "cc2").expect("nudge a re-projection"); let got = wait_recv(&rx, Duration::from_secs(5)); - assert!(got.is_some(), "the subscriber received the push-driven delta"); + assert!( + got.is_some(), + "the subscriber received the push-driven delta" + ); } /// Block up to `dur` for one value on `rx`. Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\dispatch.rs:17: use spt_daemon::brain::Brain; use spt_daemon::broker::Broker; -use spt_daemon::effect::{Minter, MintedOp}; use spt_daemon::dispatch::{run_dispatch_loop, DispatchPaths}; +use spt_daemon::effect::{MintedOp, Minter}; use spt_daemon::nethost::{NetConfig, NetHost}; use spt_daemon::propagate::{request_update, UpdatePullOutcome}; use spt_daemon::relcache::ReleaseCache; Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\dispatch.rs:180: seed_gates("d91-sync", &node_hex(&mut a), &[id]); let addr = b_probe.net_status().expect("status").addr; - let conn = a.net_dial(addr, Some(MintedOp::new(Minter::Cli, op()))).expect("dial"); + let conn = a + .net_dial(addr, Some(MintedOp::new(Minter::Cli, op()))) + .expect("dial"); let cs_a_root = dir.path().join("a-ctx"); let cs_a = ContextStore::open_or_init_in(&cs_a_root).expect("A context store"); let report = request_sync( Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\dispatch.rs:258: }; let addr = b_probe.net_status().expect("status").addr; - let conn = a.net_dial(addr, Some(MintedOp::new(Minter::Cli, op()))).expect("dial"); + let conn = a + .net_dial(addr, Some(MintedOp::new(Minter::Cli, op()))) + .expect("dial"); let cache_a = ReleaseCache::open(&dir.path().join("releases-a")); let outcome = request_update( &mut a, Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\dispatch.rs:313: let line = spt_net::net::ndjson::encode_line(&NotifRecord::Row { row }); let addr = b_probe.net_status().expect("status").addr; - let conn = a.net_dial(addr, Some(MintedOp::new(Minter::Cli, op()))).expect("dial"); - let opened = a.net_open_stream(conn.conn_id, Some(MintedOp::new(Minter::Cli, op()))).expect("open"); + let conn = a + .net_dial(addr, Some(MintedOp::new(Minter::Cli, op()))) + .expect("dial"); + let opened = a + .net_open_stream(conn.conn_id, Some(MintedOp::new(Minter::Cli, op()))) + .expect("open"); a.net_stream_send(opened.stream_id, &line, None, true) .expect("send feed"); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\dispatch.rs:364: let mut b_probe = connect_retry(&b_name); let addr = b_probe.net_status().expect("status").addr; - let conn = a.net_dial(addr, Some(MintedOp::new(Minter::Cli, op()))).expect("dial"); - let opened = a.net_open_stream(conn.conn_id, Some(MintedOp::new(Minter::Cli, op()))).expect("open"); + let conn = a + .net_dial(addr, Some(MintedOp::new(Minter::Cli, op()))) + .expect("dial"); + let opened = a + .net_open_stream(conn.conn_id, Some(MintedOp::new(Minter::Cli, op()))) + .expect("open"); let msg = WanMessage { target: target.to_string(), from: "doyle".to_string(), Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\dispatch.rs:465: let mut a = connect_retry(&a_name); let mut b_probe = connect_retry(&b_name); let addr = b_probe.net_status().expect("status").addr; - let conn = a.net_dial(addr, Some(MintedOp::new(Minter::Cli, op()))).expect("dial"); + let conn = a + .net_dial(addr, Some(MintedOp::new(Minter::Cli, op()))) + .expect("dial"); // Unlabeled session: the dispatcher refuses (our read side finishes // without a single Output record). Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\dispatch.rs:472: - let refused = spt_daemon::attach::request_attach(&mut a, conn.conn_id, unlabeled, 0, MintedOp::new(Minter::Rc, op()), spt_net::net::attach::AttachIntent::Control) - .expect("open refused viewport"); + let refused = spt_daemon::attach::request_attach( + &mut a, + conn.conn_id, + unlabeled, + 0, + MintedOp::new(Minter::Rc, op()), + spt_net::net::attach::AttachIntent::Control, + ) + .expect("open refused viewport"); a.net_stream_subscribe(refused, 0).expect("subscribe"); loop { match a.read_event().expect("event") { Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\dispatch.rs:489: } // Labeled session: attach, type, read the echo back — all undriven. - let viewport = spt_daemon::attach::request_attach(&mut a, conn.conn_id, labeled, 0, MintedOp::new(Minter::Rc, op()), spt_net::net::attach::AttachIntent::Control) - .expect("open viewport"); + let viewport = spt_daemon::attach::request_attach( + &mut a, + conn.conn_id, + labeled, + 0, + MintedOp::new(Minter::Rc, op()), + spt_net::net::attach::AttachIntent::Control, + ) + .expect("open viewport"); a.net_stream_subscribe(viewport, 0).expect("subscribe"); spt_daemon::attach::send_attach_input(&mut a, viewport, b"dispatch-driven\r\n", op()) .expect("type"); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\dispatch.rs:563: let mut a = connect_retry(&a_name); let mut b_probe = connect_retry(&b_name); let addr = b_probe.net_status().expect("status").addr; - let conn = a.net_dial(addr, Some(MintedOp::new(Minter::Cli, op()))).expect("dial"); + let conn = a + .net_dial(addr, Some(MintedOp::new(Minter::Cli, op()))) + .expect("dial"); // Attach BY ENDPOINT (session_id = 0 placeholder). B resolves it server-side. let viewport = spt_daemon::attach::request_attach_endpoint( Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\dispatch.rs:681: let mut a = connect_retry(&a_name); let mut b_probe = connect_retry(&b_name); let addr = b_probe.net_status().expect("status").addr; - let conn = a.net_dial(addr, Some(MintedOp::new(Minter::Cli, op()))).expect("dial"); + let conn = a + .net_dial(addr, Some(MintedOp::new(Minter::Cli, op()))) + .expect("dial"); let dest = dir.path().join("pulled.md"); let n = spt_daemon::xfer::fetch_file( Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\dispatch.rs:812: // applies it and surfaces it under B's own presence resolution. let line = spt_net::net::ndjson::encode_line(&NotifRecord::Row { row: row.clone() }); let addr = b_probe.net_status().expect("status").addr; - let conn = a.net_dial(addr, Some(MintedOp::new(Minter::Cli, op()))).expect("dial"); - let opened = a.net_open_stream(conn.conn_id, Some(MintedOp::new(Minter::Cli, op()))).expect("open"); + let conn = a + .net_dial(addr, Some(MintedOp::new(Minter::Cli, op()))) + .expect("dial"); + let opened = a + .net_open_stream(conn.conn_id, Some(MintedOp::new(Minter::Cli, op()))) + .expect("open"); a.net_stream_send(opened.stream_id, &line, None, true) .expect("send feed"); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\dispatch.rs:896: let mut a = connect_retry(&a_name); let mut b_probe = connect_retry(&b_name); let addr = b_probe.net_status().expect("status").addr; - let conn = a.net_dial(addr, Some(MintedOp::new(Minter::Cli, op()))).expect("dial"); + let conn = a + .net_dial(addr, Some(MintedOp::new(Minter::Cli, op()))) + .expect("dial"); // Relink: the binary relaunches on B; a fresh token parks. let out = request_shell_link( Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\dispatch.rs:999: let mut a = connect_retry(&a_name); let mut b_probe = connect_retry(&b_name); let addr = b_probe.net_status().expect("status").addr; - let conn = a.net_dial(addr, Some(MintedOp::new(Minter::Cli, op()))).expect("dial"); + let conn = a + .net_dial(addr, Some(MintedOp::new(Minter::Cli, op()))) + .expect("dial"); // Attached member → serving. assert!( Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\dispatch.rs:1043: #[test] fn classify_routes_a_node_label_feed_to_registry() { use spt_daemon::dispatch::{classify_first_line, StreamFamily}; - use spt_net::net::replicate::{NodeLabelUpdate, RegistryFeedRecord, RegistryUpdate}; use spt_net::net::registry::{Instance, Status}; + use spt_net::net::replicate::{NodeLabelUpdate, RegistryFeedRecord, RegistryUpdate}; let label = RegistryFeedRecord::NodeLabel(NodeLabelUpdate { subnet: "home".into(), Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\dispatch.rs:1106: seed_gates("d91-unk", &node_hex(&mut a), &[]); let addr = b_probe.net_status().expect("status").addr; - let conn = a.net_dial(addr, Some(MintedOp::new(Minter::Cli, op()))).expect("dial"); + let conn = a + .net_dial(addr, Some(MintedOp::new(Minter::Cli, op()))) + .expect("dial"); // Garbage stream: not JSON at all. let junk = a Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\driven_by_selfheal.rs:72: use std::time::Duration; use spt_daemon::brain::Brain; +use spt_daemon::livehost::reconcile_hosted_liveness; use spt_daemon::msg::SpawnReq; use spt_daemon::Broker; -use spt_daemon::livehost::reconcile_hosted_liveness; use spt_store::perch::{self, owlery_dir, ParentHint}; Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\driven_by_selfheal.rs:335: live_present, "the broker MUST list a LIVE session for the endpoint (the session survives \ the controller drop). sessions={:?}", - reply.sessions.iter().map(|s| &s.endpoint).collect::>() + reply + .sessions + .iter() + .map(|s| &s.endpoint) + .collect::>() ); assert!( observed_controller_by.is_none(), Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\endpoint_survival.rs:60: use spt_store::perch::{resolve_perch_path, resolve_ready_file, ParentHint}; let perch = resolve_perch_path(id, ParentHint::Infer); std::fs::create_dir_all(&perch).unwrap(); - let mut rec = spt_store::info::InfoJson::new(id, "0", std::process::id(), "sid-prev", "live_agent"); + let mut rec = + spt_store::info::InfoJson::new(id, "0", std::process::id(), "sid-prev", "live_agent"); rec.adapter = Some(adapter.to_string()); // controllable == Some(true): the doyle-Q1 spt-hosted discriminator (broker-PTY), // NOT a user-terminal (Some(false)) or legacy (None) record. Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\false_promote.rs:248: let sid = loop { let f = read_frame(&mut a).expect("frame before spawned"); if f.kind == KIND_SPAWNED { - break serde_json::from_value::(f.payload).unwrap().session_id; + break serde_json::from_value::(f.payload) + .unwrap() + .session_id; } }; // A goes silent forever holding the conn — its broker-side writer wedges on the Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\idempotent.rs:32: use std::time::Duration; use spt_daemon::brain::{Brain, BrainState, BrokerEvent}; -use spt_daemon::effect::{EffectKey, Minter, MintedOp}; +use spt_daemon::effect::{EffectKey, MintedOp, Minter}; use spt_daemon::msg::SpawnReq; use spt_daemon::Broker; Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\inject_control_wedge.rs:65: // ── W1b additions (REQ-HAZARD-EFFECT-JOURNAL-PTY-WEDGE): the real-fixture attach // path, the Brain client API, and a net-backed broker for loopback attach. ── -use std::sync::atomic::{AtomicBool, AtomicU64}; -use std::sync::OnceLock; use spt_daemon::attach::{request_attach, serve_attach}; use spt_daemon::brain::{Brain, BrokerEvent}; -use spt_daemon::effect::{Minter, MintedOp}; +use spt_daemon::effect::{MintedOp, Minter}; use spt_daemon::msg::decode_bytes; use spt_daemon::nethost::{NetConfig, NetHost}; use spt_net::net::attach::{AttachDecoder, AttachIntent, AttachRecord}; Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\inject_control_wedge.rs:76: use spt_net::net::endpoint::{BindScope, LocalDiscovery, RelayPolicy}; use spt_proto::identity::Identity; +use std::sync::atomic::{AtomicBool, AtomicU64}; +use std::sync::OnceLock; use std::sync::atomic::{AtomicU32, Ordering}; static SEQ: AtomicU32 = AtomicU32::new(0); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\inject_control_wedge.rs:313: let sid = loop { let f = read_frame(&mut a).expect("frame before spawned"); if f.kind == KIND_SPAWNED { - break serde_json::from_value::(f.payload).unwrap().session_id; + break serde_json::from_value::(f.payload) + .unwrap() + .session_id; } }; Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\inject_control_wedge.rs:331: // session's log (`delivered_through`) under each log lock — PRE-FIX it hung on // the parked session's held lock; POST-FIX it answers because the drain no // longer holds the lock during the controller send. - let broker_alive = probe(&name, KIND_NET_STATUS, KIND_NET_STATUS_REPLY, Duration::from_secs(5)); - let sessions_answered = - probe(&name, KIND_SESSIONS, KIND_SESSIONS_REPLY, Duration::from_secs(5)); + let broker_alive = probe( + &name, + KIND_NET_STATUS, + KIND_NET_STATUS_REPLY, + Duration::from_secs(5), + ); + let sessions_answered = probe( + &name, + KIND_SESSIONS, + KIND_SESSIONS_REPLY, + Duration::from_secs(5), + ); eprintln!( "=== W1 GATE: broker_alive(net_status)={broker_alive} \ Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\inject_control_wedge.rs:401: let sid = loop { let f = read_frame(&mut a).expect("frame before spawned"); if f.kind == KIND_SPAWNED { - break serde_json::from_value::(f.payload).unwrap().session_id; + break serde_json::from_value::(f.payload) + .unwrap() + .session_id; } }; // Keep the controller socket drained so append never parks. Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\inject_control_wedge.rs:464: let spooled = ack == Some(false); // Broker process still alive on a fresh connection. - let broker_alive = probe(&name, KIND_NET_STATUS, KIND_NET_STATUS_REPLY, Duration::from_secs(5)); + let broker_alive = probe( + &name, + KIND_NET_STATUS, + KIND_NET_STATUS_REPLY, + Duration::from_secs(5), + ); eprintln!( "=== NO-BINARY SPOOL GATE: inject_acked={inject_acked} spooled={spooled} \ Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\inject_control_wedge.rs:638: // the journal lock) until teardown. Each send_effect writes a frame; the // pump reader drains replies concurrently so the write never deadlocks. while !driver_stop.load(std::sync::atomic::Ordering::Relaxed) { - if w.send_effect(MintedOp::new(Minter::Rc, op), &chunk).is_err() { + if w.send_effect(MintedOp::new(Minter::Rc, op), &chunk) + .is_err() + { break; } driver_pumped.fetch_add(1, std::sync::atomic::Ordering::Relaxed); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\inject_control_wedge.rs:740: assert_eq!(origin, own_origin, "loopback origin is this node's own id"); let serve_broker = attach_name.clone(); let server = thread::spawn(move || { - let _ = serve_attach(&mut target, &serve_broker, stream_a, "wedge-jrnl-ep", &origin, 0, None); + let _ = serve_attach( + &mut target, + &serve_broker, + stream_a, + "wedge-jrnl-ep", + &origin, + 0, + None, + ); }); // The positive W1 LACKED: a real rc-client attach actually RECEIVES PTY Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\inject_control_wedge.rs:751: let mut got_output = false; let deadline = std::time::Instant::now() + Duration::from_secs(8); while std::time::Instant::now() < deadline { - match operator.read_event_until(Some( - std::time::Instant::now() + Duration::from_millis(250), - )) { - Ok(BrokerEvent::NetStreamData { stream_id, bytes, .. }) if stream_id == stream_b => { + match operator + .read_event_until(Some(std::time::Instant::now() + Duration::from_millis(250))) + { + Ok(BrokerEvent::NetStreamData { + stream_id, bytes, .. + }) if stream_id == stream_b => { for rec in decoder.push(&bytes) { if let AttachRecord::Output { data_b64, .. } = rec { let chunk = decode_bytes(&data_b64).unwrap_or_default(); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\inject_control_wedge.rs:803: // serviced-but-late request_attach ack under CI scheduler starvation. let watchdog = attach_gate_watchdog(); let recv_t0 = Instant::now(); - let (subscribed, got_output) = result_rx - .recv_timeout(watchdog) - .unwrap_or((false, false)); + let (subscribed, got_output) = result_rx.recv_timeout(watchdog).unwrap_or((false, false)); let recv_elapsed = recv_t0.elapsed(); // Source-attribution (cheap, load-bearing triage): `channel` = the attacher // reported; `WATCHDOG-DEFAULT` = the gate's elastic bound (request_attach's Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\inject_control_wedge.rs:842: // broker down — the probe needs a live broker). On Windows the journaled write // is absorbed, so there is no park to assert liveness against. #[cfg(unix)] - let alive = probe(&name, KIND_NET_STATUS, KIND_NET_STATUS_REPLY, Duration::from_secs(5)); + let alive = probe( + &name, + KIND_NET_STATUS, + KIND_NET_STATUS_REPLY, + Duration::from_secs(5), + ); // ── PROCESS-CLEAN-EXIT teardown (test-robustness, not the gate). ── // Each `cold_start_pump` Brain (the driver's `w`, the attacher's `operator`) Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\inject_control_wedge.rs:986: } b.expect("brain could not connect (pump)") }; - let sid = spawner.spawn_session(req).expect("spawn translation-bearing session"); + let sid = spawner + .spawn_session(req) + .expect("spawn translation-bearing session"); (broker, sid, spawner) } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\inject_control_wedge.rs:1167: loop { match read_frame(&mut conn) { Ok(f) if f.kind == KIND_ENDPOINT_INJECTED => { - let delivered = - f.payload.get("delivered").and_then(|d| d.as_bool()).unwrap_or(false); - let spool_deferred = - f.payload.get("spool_deferred").and_then(|d| d.as_bool()).unwrap_or(false); + let delivered = f + .payload + .get("delivered") + .and_then(|d| d.as_bool()) + .unwrap_or(false); + let spool_deferred = f + .payload + .get("spool_deferred") + .and_then(|d| d.as_bool()) + .unwrap_or(false); let _ = tx.send((delivered, spool_deferred)); return; } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\inject_control_wedge.rs:1248: /// Resolved through the SAME `resolve_idle_file(endpoint, Infer)` the broker reads, /// so the path matches by construction regardless of the test home. fn set_endpoint_idle(endpoint: &str) { - let idle = - spt_store::perch::resolve_idle_file(endpoint, spt_store::perch::ParentHint::Infer); + let idle = spt_store::perch::resolve_idle_file(endpoint, spt_store::perch::ParentHint::Infer); if let Some(parent) = idle.parent() { std::fs::create_dir_all(parent).expect("create perch dir for .idle sentinel"); } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\inject_control_wedge.rs:1283: let drain_stop = Arc::clone(&stop); let drainer = thread::spawn(move || { while !drain_stop.load(Ordering::Relaxed) { - let _ = - controller.read_event_until(Some(Instant::now() + Duration::from_millis(100))); + let _ = controller.read_event_until(Some(Instant::now() + Duration::from_millis(100))); } controller // hand it back so it is dropped only after teardown }); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\inject_control_wedge.rs:1311: // (the W1 non-wedge bar): KIND_SESSIONS still answers, and a FRESH attach drives // input and sees it echo back (XON-resumed). Injection coexisted with the live // controller via the floor. - let sessions_answered = - probe(&name, KIND_SESSIONS, KIND_SESSIONS_REPLY, Duration::from_secs(5)); + let sessions_answered = probe( + &name, + KIND_SESSIONS, + KIND_SESSIONS_REPLY, + Duration::from_secs(5), + ); let fresh_attach_served = observe_with_xon(&name, sid, b"G1_FRESH_MARKER", true, Duration::from_secs(8)); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\inject_control_wedge.rs:1423: output_contains_within(&name, sid, b"OPERATOR_KEYS_FLUSHED", Duration::from_secs(8)); // The session stays serviceable after the FAULT. - let sessions_answered = - probe(&name, KIND_SESSIONS, KIND_SESSIONS_REPLY, Duration::from_secs(5)); + let sessions_answered = probe( + &name, + KIND_SESSIONS, + KIND_SESSIONS_REPLY, + Duration::from_secs(5), + ); // After the binary FAULTS, the steady-state contract is: a subsequent inbound // delivery SPOOLS (delivered=false) and writes NOTHING to the PTY (ADR-0022 Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\inject_control_wedge.rs:1478: // [int->REQ-MSG-IDLE-TRANSLATION-BINARY] // [int->REQ-HAZARD-IDLE-SILENT-NONDELIVERY] - assert!(delivered, "the no-commit event must still be accepted by the broker"); assert!( + delivered, + "the no-commit event must still be accepted by the broker" + ); + assert!( op_flushed, "after the commit deadline the floor must RELEASE and buffered operator \ keystrokes must flush to the PTY — the controller's input must NOT wedge \ Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\inject_control_wedge.rs:1527: let secret = b"SECRET_OPERATOR_KEYSTROKES_1234"; for _ in 0..6 { let _ = controller.send_input(b"SECRET_OPERATOR_KEYSTROKES_1234\r"); - let _ = - controller.read_event_until(Some(Instant::now() + Duration::from_millis(40))); + let _ = controller.read_event_until(Some(Instant::now() + Duration::from_millis(40))); } // The secret must reach the PTY (it is a real operator keystroke), echoed back… - let secret_on_pty = - output_contains_within(&name, sid, secret, Duration::from_secs(8)); + let secret_on_pty = output_contains_within(&name, sid, secret, Duration::from_secs(8)); // …but must NEVER appear in the binary's stdin log. Give the pings time to land, // then assert the binary's stdin contains only `init` / `input` (and any `event`) // lines — no operator payload. Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\inject_control_wedge.rs:1582: let name = unique_name(); let endpoint = "xlate-g4-ep"; - let (broker, sid, _controller) = - spawn_xlate_session(&name, &dir.path().join("g4"), endpoint); + let (broker, sid, _controller) = spawn_xlate_session(&name, &dir.path().join("g4"), endpoint); // Capture the translation child's pid via its OS process table presence. The // broker does not surface the translation child's pid directly, so we discover Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\inject_control_wedge.rs:1671: let name = unique_name(); let endpoint = "xlate-g5-ep"; - let (broker, sid, _controller) = - spawn_xlate_session(&name, &dir.path().join("g5"), endpoint); + let (broker, sid, _controller) = spawn_xlate_session(&name, &dir.path().join("g5"), endpoint); // Deliberately NO set_endpoint_idle → the endpoint is ACTIVE (the default window). let envelope = br#"active-window message"#; Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\inject_control_wedge.rs:1744: let name = unique_name(); let endpoint = "xlate-g6-ep"; - let (broker, sid, _controller) = - spawn_xlate_session(&name, &dir.path().join("g6"), endpoint); + let (broker, sid, _controller) = spawn_xlate_session(&name, &dir.path().join("g6"), endpoint); // IDLE window so the inbound routes to the binary (which then faults). set_endpoint_idle(endpoint); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\inject_control_wedge.rs:1812: let perch_path = spt_store::perch::resolve_perch_path(endpoint, spt_store::perch::ParentHint::Infer); std::fs::create_dir_all(&perch_path).expect("create perch dir"); - let mut rec = spt_store::info::InfoJson::new(endpoint, "0", std::process::id(), "sid", "live_agent"); + let mut rec = + spt_store::info::InfoJson::new(endpoint, "0", std::process::id(), "sid", "live_agent"); rec.controllable = Some(true); spt_store::info::write_info(&perch_path, &rec).expect("write info.json"); } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\inject_control_wedge.rs:1862: let name = unique_name(); let endpoint = "xlate-c1a-ep"; establish_endpoint_perch(endpoint); - let (broker, sid, _controller) = - spawn_xlate_session(&name, &dir.path().join("c1a"), endpoint); + let (broker, sid, _controller) = spawn_xlate_session(&name, &dir.path().join("c1a"), endpoint); set_endpoint_idle(endpoint); // Event 1 MISSES its {commit} (nocommit_once). Under C-1 this must NOT fault: Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\inject_control_wedge.rs:1959: let name = unique_name(); let endpoint = "xlate-c1b-ep"; establish_endpoint_perch(endpoint); - let (broker, sid, _controller) = - spawn_xlate_session(&name, &dir.path().join("c1b"), endpoint); + let (broker, sid, _controller) = spawn_xlate_session(&name, &dir.path().join("c1b"), endpoint); set_endpoint_idle(endpoint); // Deliver events with > deadline spacing so each fresh binary faults BEFORE the Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\inject_control_wedge.rs:1971: for i in 0..8 { attempts += 1; let env = format!(r#"c1b-miss-{i}"#); - let delivered = deliver_endpoint_event(&name, endpoint, env.as_bytes(), Duration::from_secs(3)); + let delivered = + deliver_endpoint_event(&name, endpoint, env.as_bytes(), Duration::from_secs(3)); if !delivered { saw_spool = true; // give-up reached → spool (delivered=false) break; Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\inject_control_wedge.rs:2054: let drain_stop = Arc::clone(&stop); let drainer = thread::spawn(move || { while !drain_stop.load(Ordering::Relaxed) { - let _ = - controller.read_event_until(Some(Instant::now() + Duration::from_millis(100))); + let _ = controller.read_event_until(Some(Instant::now() + Duration::from_millis(100))); } controller }); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\inject_control_wedge.rs:2107: let deadline = Instant::now() + Duration::from_secs(5); while Instant::now() < deadline { let out = std::process::Command::new("tasklist") - .args(["/FI", "IMAGENAME eq xlate_choreo_fixture.exe", "/NH", "/FO", "CSV"]) + .args([ + "/FI", + "IMAGENAME eq xlate_choreo_fixture.exe", + "/NH", + "/FO", + "CSV", + ]) .output() .ok()?; let s = String::from_utf8_lossy(&out.stdout); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\inject_control_wedge.rs:2310: let perch = spt_store::perch::resolve_perch_path(endpoint, spt_store::perch::ParentHint::Infer); std::fs::create_dir_all(&perch).expect("create perch dir"); - let info = spt_store::info::InfoJson::new(endpoint, "2026-06-19T00:00:00Z", 0, "", "online"); + let info = + spt_store::info::InfoJson::new(endpoint, "2026-06-19T00:00:00Z", 0, "", "online"); spt_store::info::write_info(&perch, &info).expect("seed perch info.json"); } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\inject_control_wedge.rs:2344: // it here keeps the controller slot occupied by Some(origin). let serve_broker = serve_name.clone(); let _ = serve_stop; // abandoned, not signalled (the "lost detach" shape) - let _ = serve_attach(&mut target, &serve_broker, stream_a, "w5-a2-ep", &origin, 0, None); + let _ = serve_attach( + &mut target, + &serve_broker, + stream_a, + "w5-a2-ep", + &origin, + 0, + None, + ); }); // The operator side: dial loopback + request the attach so the slot fills. Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\inject_control_wedge.rs:2545: let chunk = vec![b'P'; 4 * 1024]; let mut op = 1u64; while !driver_stop.load(Ordering::Relaxed) { - if w.send_effect(MintedOp::new(Minter::Rc, op), &chunk).is_err() { + if w.send_effect(MintedOp::new(Minter::Rc, op), &chunk) + .is_err() + { break; } driver_pumped.fetch_add(1, Ordering::Relaxed); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\inject_control_wedge.rs:2643: assert_eq!(origin, own_origin, "loopback origin is this node's own id"); let serve_broker = attach_name.clone(); let server = thread::spawn(move || { - let _ = serve_attach(&mut target, &serve_broker, stream_a, "p0-paste-wedge-ep", &origin, 0, None); + let _ = serve_attach( + &mut target, + &serve_broker, + stream_a, + "p0-paste-wedge-ep", + &origin, + 0, + None, + ); }); let mut decoder = AttachDecoder::new(); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\inject_control_wedge.rs:2651: let deadline = Instant::now() + Duration::from_secs(8); while Instant::now() < deadline { match operator.read_event_until(Some(Instant::now() + Duration::from_millis(250))) { - Ok(BrokerEvent::NetStreamData { stream_id, bytes, .. }) if stream_id == stream_b => { + Ok(BrokerEvent::NetStreamData { + stream_id, bytes, .. + }) if stream_id == stream_b => { for rec in decoder.push(&bytes) { if let AttachRecord::Output { data_b64, .. } = rec { let chunk = decode_bytes(&data_b64).unwrap_or_default(); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\inject_control_wedge.rs:2688: // request_attach ack under CI scheduler starvation (never relaxes the asserts). let watchdog = attach_gate_watchdog(); let recv_t0 = Instant::now(); - let (subscribed, got_output) = result_rx - .recv_timeout(watchdog) - .unwrap_or((false, false)); + let (subscribed, got_output) = result_rx.recv_timeout(watchdog).unwrap_or((false, false)); let recv_elapsed = recv_t0.elapsed(); // Source-attribution (cheap, load-bearing triage); threshold derived from the // CONFIGURED watchdog so the label stays truthful at 30s OR 120s. Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\inject_control_wedge.rs:2896: // + op-id/spool bookkeeping resolve (the broker matches its live session by the // endpoint NAME in-memory, independent of this path). `set_endpoint_idle` made // the dir; stamp a live_agent info record so the perch reads as established. - let perch_path = spt_store::perch::resolve_perch_path( - endpoint, - spt_store::perch::ParentHint::Infer, - ); + let perch_path = + spt_store::perch::resolve_perch_path(endpoint, spt_store::perch::ParentHint::Infer); let mut rec = spt_store::info::InfoJson::new(endpoint, "0", std::process::id(), "sid", "live_agent"); // `controllable = Some(true)`: a broker-PTY-controllable live-agent endpoint — Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\inject_control_wedge.rs:2950: // BYTE RECEIPT: the binary's `{text:"XLATE_OK"}` choreography actually reached // the PTY — observed via the echo child over the REAL broker ring, XON-unsticking // the choreography's XOFF exactly as g1 does (the real-receipt seam, not liveness). - let payload_reached = - observe_with_xon(&name, sid, b"XLATE_OK", false, Duration::from_secs(12)); + let payload_reached = observe_with_xon(&name, sid, b"XLATE_OK", false, Duration::from_secs(12)); // No spool row survived: a delivered inject claims the op (wan_mark_seen_at) and // spools NOTHING. Today receive_wan spools the arrival → this count is 1. Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\inject_control_wedge.rs:3057: let drain_stop = Arc::clone(&stop); let drainer = thread::spawn(move || { while !drain_stop.load(Ordering::Relaxed) { - let _ = - controller.read_event_until(Some(Instant::now() + Duration::from_millis(100))); + let _ = controller.read_event_until(Some(Instant::now() + Duration::from_millis(100))); } controller }); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\inject_control_wedge.rs:3094: stop.store(true, Ordering::Relaxed); let _ = drainer.join(); - eprintln!("=== W5 B PARKED-IDLE: drained={delivered} audit_rows={} ===", audit.len()); + eprintln!( + "=== W5 B PARKED-IDLE: drained={delivered} audit_rows={} ===", + audit.len() + ); assert_eq!( delivered, 1, Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\inject_control_wedge.rs:3143: let name = unique_name(); let endpoint = "xlate-w5a-big-ep"; - let (broker, sid, mut controller) = - spawn_session_with(&name, &dir.path().join("w5a-big"), xlate_spawn_req(endpoint)); + let (broker, sid, mut controller) = spawn_session_with( + &name, + &dir.path().join("w5a-big"), + xlate_spawn_req(endpoint), + ); set_endpoint_idle(endpoint); let stop = Arc::new(AtomicBool::new(false)); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\inject_control_wedge.rs:3151: let drain_stop = Arc::clone(&stop); let drainer = thread::spawn(move || { while !drain_stop.load(Ordering::Relaxed) { - let _ = - controller.read_event_until(Some(Instant::now() + Duration::from_millis(100))); + let _ = controller.read_event_until(Some(Instant::now() + Duration::from_millis(100))); } controller }); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\inject_control_wedge.rs:3161: let mut delivered_ok = 0usize; for i in 0..N { let envelope = format!(r#"big #{i}"#); - if deliver_endpoint_event(&name, endpoint, envelope.as_bytes(), Duration::from_secs(10)) { + if deliver_endpoint_event( + &name, + endpoint, + envelope.as_bytes(), + Duration::from_secs(10), + ) { delivered_ok += 1; } // BYTE RECEIPT is forkpty-HARD / ConPTY-CAPTURE (a programmatically-injected Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\inject_control_wedge.rs:3191: let _ = drainer.join(); eprintln!("=== W5-A BIGMULTILINE x{N}: delivered={delivered_ok} (forkpty asserts HEAD+TAIL echo per inject) ==="); - assert_eq!(delivered_ok, N, "every inject in the loop is accepted + delivered"); + assert_eq!( + delivered_ok, N, + "every inject in the loop is accepted + delivered" + ); } /// Layer 2 wiring, RED-first + deterministic on any platform: when echo-verify reports a Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\inject_control_wedge.rs:3215: let name = unique_name(); let endpoint = "xlate-w5a-forced-ep"; - let (broker, sid, mut controller) = - spawn_session_with(&name, &dir.path().join("w5a-forced"), xlate_spawn_req(endpoint)); + let (broker, sid, mut controller) = spawn_session_with( + &name, + &dir.path().join("w5a-forced"), + xlate_spawn_req(endpoint), + ); set_endpoint_idle(endpoint); let perch_path = spt_store::perch::resolve_perch_path(endpoint, spt_store::perch::ParentHint::Infer); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\inject_control_wedge.rs:3225: let drain_stop = Arc::clone(&stop); let drainer = thread::spawn(move || { while !drain_stop.load(Ordering::Relaxed) { - let _ = - controller.read_event_until(Some(Instant::now() + Duration::from_millis(100))); + let _ = controller.read_event_until(Some(Instant::now() + Duration::from_millis(100))); } controller }); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\inject_control_wedge.rs:3239: let mut pending = 0; for _ in 0..60 { events = std::fs::read_to_string(&stdin_log) - .map(|s| s.lines().filter(|l| l.contains("\"type\":\"event\"")).count()) + .map(|s| { + s.lines() + .filter(|l| l.contains("\"type\":\"event\"")) + .count() + }) .unwrap_or(0); pending = spt_store::spool::pending_count_at(&perch_path).unwrap_or(0); if events >= INJECT_REDRIVE_ATTEMPTS_INT && pending >= 1 { Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\inject_control_wedge.rs:3259: (2 events = the one re-drive; pending≥1 = loud recoverable spool, not a silent truncation) ===" ); - assert!(delivered, "the broker accepts the endpoint event (queued to the live worker)"); + assert!( + delivered, + "the broker accepts the endpoint event (queued to the live worker)" + ); assert_eq!( events, INJECT_REDRIVE_ATTEMPTS_INT, "an echo-verify miss RE-DRIVES the sequence exactly once (2 binary events for one delivery)" Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\input_ack_deadlock.rs:69: use spt_daemon::attach::{request_attach, send_attach_input, serve_attach}; use spt_daemon::brain::{Brain, BrokerEvent}; -use spt_daemon::effect::{Minter, MintedOp}; use spt_daemon::codec::{read_frame, write_frame}; +use spt_daemon::effect::{MintedOp, Minter}; use spt_daemon::frame::{Envelope, Role}; use spt_daemon::msg::{ decode_bytes, SpawnReq, KIND_NET_STATUS, KIND_NET_STATUS_REPLY, KIND_SESSIONS, Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\input_ack_deadlock.rs:128: // NO stdout and does NOT read stdin — the Windows "silent sleep" we need. let (program, args) = ( "waitfor".to_string(), - vec!["/t".to_string(), "600".to_string(), "AckDlNoSignal".to_string()], + vec![ + "/t".to_string(), + "600".to_string(), + "AckDlNoSignal".to_string(), + ], ); SpawnReq { program, Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\input_ack_deadlock.rs:355: assert_eq!(origin, own_origin, "loopback origin is this node's own id"); let serve_broker = flood_name.clone(); let server = thread::spawn(move || { - let _ = serve_attach(&mut target, &serve_broker, stream_a, &flood_ep, &origin, 0, None); + let _ = serve_attach( + &mut target, + &serve_broker, + stream_a, + &flood_ep, + &origin, + 0, + None, + ); }); // THE FLOOD: FLOOD_N input records, back-to-back, NO reads in between — the Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\input_ack_deadlock.rs:400: // table the wedged flood handler would otherwise hold); `KIND_NET_STATUS` // proves the process answers at all. Pre-fix the flood's per-conn handler is // deadlocked and a fresh conn's KIND_SESSIONS never answers. ── - let broker_alive = - probe(&name, KIND_NET_STATUS, KIND_NET_STATUS_REPLY, Duration::from_secs(8)); - let sessions_answered = - probe(&name, KIND_SESSIONS, KIND_SESSIONS_REPLY, Duration::from_secs(8)); + let broker_alive = probe( + &name, + KIND_NET_STATUS, + KIND_NET_STATUS_REPLY, + Duration::from_secs(8), + ); + let sessions_answered = probe( + &name, + KIND_SESSIONS, + KIND_SESSIONS_REPLY, + Duration::from_secs(8), + ); // ── (B) The CONCURRENT viewer attach — the non-vacuous proof the broker is NOT // wedged. A SEPARATE operator dials loopback, requests a VIEWER attach, Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\input_ack_deadlock.rs:458: assert_eq!(origin, own_origin, "loopback origin is this node's own id"); let serve_broker = attach_name.clone(); let server = thread::spawn(move || { - let _ = serve_attach(&mut target, &serve_broker, stream_a, &attach_ep, &origin, 0, None); + let _ = serve_attach( + &mut target, + &serve_broker, + stream_a, + &attach_ep, + &origin, + 0, + None, + ); }); // Real byte receipt: the viewer must actually RECEIVE PTY output — here the Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\input_ack_deadlock.rs:477: // re-emitting the flooded input, so frames keep arriving and the OUTER // deadline check fires between them; `got_output` then breaks promptly. while Instant::now() < deadline { - match operator.read_event_until(Some(Instant::now() + Duration::from_millis(250))) - { + match operator.read_event_until(Some(Instant::now() + Duration::from_millis(250))) { Ok(BrokerEvent::NetStreamData { stream_id, bytes, .. }) if stream_id == stream_b => { Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\legacy_resident_sweep_e2e.rs:157: // SWEPT: the positive-match legacy wrapper is reaped ... assert!( - wait_until(Duration::from_secs(5), || !spt_store::proc::is_process_alive(mock_pid)), + wait_until(Duration::from_secs(5), || { + !spt_store::proc::is_process_alive(mock_pid) + }), "the matching legacy wrapper must be SWEPT (RED if the kill is bypassed)" ); // ... and its residue (the stale `-psyche` ready registration) is CLEARED. Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\legacy_resident_sweep_e2e.rs:166: "the stale `legacyhost-psyche` ready registration (info.json) must be cleared (pin 3)" ); assert!( - !perch::resolve_ready_file("legacyhost-psyche", ParentHint::Explicit("legacyhost")).exists(), + !perch::resolve_ready_file("legacyhost-psyche", ParentHint::Explicit("legacyhost")) + .exists(), "the stale `legacyhost-psyche` `ready` marker must be cleared (pin 3)" ); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\mesh.rs:146: /// Stand up a node under `root`: broker, a single advertised perch, a /// registry, and pump paths whose roster lists exactly `members` (the push /// target — seed the full mesh membership for the converged-roster state). - fn new(root: &std::path::Path, perch_id: &str, members: &[&str], dir: &std::path::Path) -> Self { + fn new( + root: &std::path::Path, + perch_id: &str, + members: &[&str], + dir: &std::path::Path, + ) -> Self { let name = unique_name(); let _broker = net_broker(&name, &root.join("broker")); let mut probe = connect_retry(&name); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\mesh.rs:420: // Regression (REQ-MESH-3): no row was relayed — every registry row A and C // hold is authored by the node that owns that perch (origin == author). - assert_no_relay(&a, &[("perchA", &a.hex), ("perchB", &b.hex), ("perchC", &c.hex)]); - assert_no_relay(&c, &[("perchA", &a.hex), ("perchB", &b.hex), ("perchC", &c.hex)]); + assert_no_relay( + &a, + &[("perchA", &a.hex), ("perchB", &b.hex), ("perchC", &c.hex)], + ); + assert_no_relay( + &c, + &[("perchA", &a.hex), ("perchB", &b.hex), ("perchC", &c.hex)], + ); a_stop2.store(true, Ordering::Relaxed); c_stop2.store(true, Ordering::Relaxed); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\mesh.rs:465: // Regression (REQ-MESH-3): B never relays — every row each node holds is // own-authored (the perchC row in A came straight from C, not via B). - let owners: [(&str, &str); 3] = - [("perchA", &a.hex), ("perchB", &b.hex), ("perchC", &c.hex)]; + let owners: [(&str, &str); 3] = [("perchA", &a.hex), ("perchB", &b.hex), ("perchC", &c.hex)]; assert_no_relay(&a, &owners); assert_no_relay(&b, &owners); assert_no_relay(&c, &owners); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\netbroker.rs:22: use std::time::Duration; use spt_daemon::brain::Brain; -use spt_daemon::effect::{EffectKey, Minter, MintedOp}; +use spt_daemon::effect::{EffectKey, MintedOp, Minter}; use spt_daemon::nethost::{NetConfig, NetHost, NET_EFFECT_SESSION}; use spt_daemon::Broker; use spt_net::net::endpoint::{BindScope, LocalDiscovery, RelayPolicy}; Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\netbroker.rs:164: const OP: u64 = 42; // Life 1: journaled dial, then "crash" (connection drop). let mut life1 = connect_retry(&name_a); - let first = life1.net_dial(addr.clone(), Some(MintedOp::new(Minter::Cli, OP))).expect("dial"); + let first = life1 + .net_dial(addr.clone(), Some(MintedOp::new(Minter::Cli, OP))) + .expect("dial"); assert!(first.applied_now, "first delivery runs the dial"); drop(life1); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\netbroker.rs:171: // Life 2: re-drives the same durable op (the brain never learned it landed). let mut life2 = connect_retry(&name_a); - let replay = life2.net_dial(addr, Some(MintedOp::new(Minter::Cli, OP))).expect("replayed dial"); + let replay = life2 + .net_dial(addr, Some(MintedOp::new(Minter::Cli, OP))) + .expect("replayed dial"); assert!(!replay.applied_now, "replay is deduped, not re-dialed"); assert_eq!( replay.conn_id, first.conn_id, Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\netbroker.rs:311: // Re-driving the SAME durable op still ATTEMPTS (errors again) rather than // dedup-succeeding into a phantom — the un-applied key means a clean retry. brain_a - .net_dial(brain_b.net_status().expect("b status").addr, Some(MintedOp::new(Minter::Cli, OP))) + .net_dial( + brain_b.net_status().expect("b status").addr, + Some(MintedOp::new(Minter::Cli, OP)), + ) .expect_err("the un-applied op re-dials (re-times-out), never a phantom dedup"); } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\netstream.rs:21: use std::time::Duration; use spt_daemon::brain::{Brain, BrokerEvent}; -use spt_daemon::effect::{EffectKey, Minter, MintedOp}; +use spt_daemon::effect::{EffectKey, MintedOp, Minter}; use spt_daemon::nethost::{NetConfig, NetHost, NET_EFFECT_SESSION}; use spt_daemon::Broker; use spt_net::net::endpoint::{BindScope, LocalDiscovery, RelayPolicy}; Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\netstream.rs:155: let mut sender = connect_retry(&name_a); let mut b_probe = connect_retry(&name_b); let addr = b_probe.net_status().expect("b status").addr; - let conn = sender.net_dial(addr, Some(MintedOp::new(Minter::Cli, 1))).expect("dial"); - let opened = sender.net_open_stream(conn.conn_id, Some(MintedOp::new(Minter::Cli, 2))).expect("open"); + let conn = sender + .net_dial(addr, Some(MintedOp::new(Minter::Cli, 1))) + .expect("dial"); + let opened = sender + .net_open_stream(conn.conn_id, Some(MintedOp::new(Minter::Cli, 2))) + .expect("open"); for n in 0..KILL_AT { sender - .net_stream_send(opened.stream_id, &chunk_for(n), Some(MintedOp::new(Minter::Cli, 100 + n)), false) + .net_stream_send( + opened.stream_id, + &chunk_for(n), + Some(MintedOp::new(Minter::Cli, 100 + n)), + false, + ) .expect("send"); } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\netstream.rs:182: // broker-owned conn/stream are untouched by the receiver's brain death. for n in KILL_AT..TOTAL { sender - .net_stream_send(opened.stream_id, &chunk_for(n), Some(MintedOp::new(Minter::Cli, 100 + n)), false) + .net_stream_send( + opened.stream_id, + &chunk_for(n), + Some(MintedOp::new(Minter::Cli, 100 + n)), + false, + ) .expect("send into the dead window"); } sender Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\netstream.rs:189: - .net_stream_send(opened.stream_id, &[], Some(MintedOp::new(Minter::Cli, 100 + TOTAL)), true) + .net_stream_send( + opened.stream_id, + &[], + Some(MintedOp::new(Minter::Cli, 100 + TOTAL)), + true, + ) .expect("finish"); // Receiver life 2: re-attach, resubscribe from the durable cursor — the Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\netstream.rs:232: // Sender life 1: dial(1) + open(2) + sends 100..100+CRASH_AFTER, then crash. let mut life1 = connect_retry(&name_a); - let conn = life1.net_dial(addr.clone(), Some(MintedOp::new(Minter::Cli, 1))).expect("dial"); - let opened1 = life1.net_open_stream(conn.conn_id, Some(MintedOp::new(Minter::Cli, 2))).expect("open"); + let conn = life1 + .net_dial(addr.clone(), Some(MintedOp::new(Minter::Cli, 1))) + .expect("dial"); + let opened1 = life1 + .net_open_stream(conn.conn_id, Some(MintedOp::new(Minter::Cli, 2))) + .expect("open"); for n in 0..CRASH_AFTER { life1 - .net_stream_send(opened1.stream_id, &chunk_for(n), Some(MintedOp::new(Minter::Cli, 100 + n)), false) + .net_stream_send( + opened1.stream_id, + &chunk_for(n), + Some(MintedOp::new(Minter::Cli, 100 + n)), + false, + ) .expect("send"); } drop(life1); // crash before retiring anything from the durable source Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\netstream.rs:243: // Sender life 2: re-drive the WHOLE durable sequence with the same op ids. let mut life2 = connect_retry(&name_a); - let conn2 = life2.net_dial(addr, Some(MintedOp::new(Minter::Cli, 1))).expect("redial"); + let conn2 = life2 + .net_dial(addr, Some(MintedOp::new(Minter::Cli, 1))) + .expect("redial"); assert!(!conn2.applied_now, "dial replay deduped"); assert_eq!( conn2.conn_id, conn.conn_id, Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\netstream.rs:260: let mut deduped = 0; for n in 0..TOTAL { let ack = life2 - .net_stream_send(opened2.stream_id, &chunk_for(n), Some(MintedOp::new(Minter::Cli, 100 + n)), false) + .net_stream_send( + opened2.stream_id, + &chunk_for(n), + Some(MintedOp::new(Minter::Cli, 100 + n)), + false, + ) .expect("re-driven send") .expect("acked"); if !ack.applied_now { Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\netstream.rs:272: "exactly the pre-crash sends dedup" ); life2 - .net_stream_send(opened2.stream_id, &[], Some(MintedOp::new(Minter::Cli, 100 + TOTAL)), true) + .net_stream_send( + opened2.stream_id, + &[], + Some(MintedOp::new(Minter::Cli, 100 + TOTAL)), + true, + ) .expect("finish"); // The journal holds each net op exactly once. Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\notifsync.rs:21: use std::time::Duration; use spt_daemon::brain::{Brain, BrokerEvent}; -use spt_daemon::effect::{Minter, MintedOp}; +use spt_daemon::effect::{MintedOp, Minter}; use spt_daemon::nethost::{NetConfig, NetHost}; use spt_daemon::notifsync::{apply_notif_feed, emit_notif_feed, NotifApplyVerdict, NotifPolicy}; use spt_daemon::Broker; Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\notifsync.rs:175: .node_id_hex .expect("node id"); let addr = b_probe.net_status().expect("b status").addr; - let conn = sender.net_dial(addr, Some(MintedOp::new(Minter::Cli, 1))).expect("dial"); - let opened = sender.net_open_stream(conn.conn_id, Some(MintedOp::new(Minter::Cli, 2))).expect("open"); + let conn = sender + .net_dial(addr, Some(MintedOp::new(Minter::Cli, 1))) + .expect("dial"); + let opened = sender + .net_open_stream(conn.conn_id, Some(MintedOp::new(Minter::Cli, 2))) + .expect("open"); let wire = emit_notif_feed(&store_a, "home").expect("emit"); let split = wire.len() / 2; Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\notifsync.rs:256: .map(|s| s.stream_id) .collect(); let conn_back = b_probe - .net_dial(sender.net_status().expect("a").addr, Some(MintedOp::new(Minter::Cli, 3))) + .net_dial( + sender.net_status().expect("a").addr, + Some(MintedOp::new(Minter::Cli, 3)), + ) .expect("dial back"); let opened_back = b_probe .net_open_stream(conn_back.conn_id, Some(MintedOp::new(Minter::Cli, 4))) Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\propagate.rs:15: use std::time::Duration; use ed25519_dalek::{Signer, SigningKey}; +use spt_daemon::effect::{MintedOp, Minter}; use spt_daemon::nethost::{NetConfig, NetHost}; use spt_daemon::propagate::{ classify_status, request_update, request_update_status, serve_update, ConvergeState, Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\propagate.rs:21: UpdatePullOutcome, UpdateServeOutcome, UpdateStatusReport, }; -use spt_daemon::effect::{Minter, MintedOp}; use spt_daemon::relcache::ReleaseCache; use spt_daemon::release::{ current_platform, RejectReason, ReleaseMetadata, SignedRelease, SignedUpdateSet, Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\propagate.rs:27: UpdateArtifactMetadata, UpdateSetMetadata, VerifyPolicy, }; -use spt_daemon::update::{ - plan_verified_update_set, BrokerAbi, UpdateClass, BROKER_RESOURCE_ABI, -}; +use spt_daemon::update::{plan_verified_update_set, BrokerAbi, UpdateClass, BROKER_RESOURCE_ABI}; use spt_daemon::{Brain, Broker}; use spt_net::net::endpoint::{BindScope, LocalDiscovery, RelayPolicy}; use spt_net::net::update::UpdRecord; Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\propagate.rs:222: // A musl node fetches + verifies its OWN artifact — the W3 field gap closed // (before W3 a musl node hit NoArtifactForPlatform: no release carried musl). - let musl_plan = - plan_verified_update_set(&running, &signed, "x86_64-unknown-linux-musl", musl_bytes, &pol) - .expect("musl artifact must select + verify — no NoArtifactForPlatform"); + let musl_plan = plan_verified_update_set( + &running, + &signed, + "x86_64-unknown-linux-musl", + musl_bytes, + &pol, + ) + .expect("musl artifact must select + verify — no NoArtifactForPlatform"); assert_eq!(musl_plan.class, UpdateClass::BrainOnly); // The signature covers the musl bytes: tampered musl bytes are rejected. Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\propagate.rs:241: ); // gnu default-Linux path unchanged: a gnu node still selects the gnu artifact. - let gnu_plan = - plan_verified_update_set(&running, &signed, "x86_64-unknown-linux-gnu", gnu_bytes, &pol) - .expect("gnu artifact still selects + verifies"); + let gnu_plan = plan_verified_update_set( + &running, + &signed, + "x86_64-unknown-linux-gnu", + gnu_bytes, + &pol, + ) + .expect("gnu artifact still selects + verifies"); assert_eq!(gnu_plan.class, UpdateClass::BrainOnly); // Selection stays exact: a platform absent from the set is rejected loudly. Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\propagate.rs:333: .collect(); let mut req_brain = connect_retry(&requester.name); - let conn = req_brain.net_dial(addr, Some(MintedOp::new(Minter::Cli, op()))).expect("dial"); + let conn = req_brain + .net_dial(addr, Some(MintedOp::new(Minter::Cli, op()))) + .expect("dial"); let open_op = op(); let running = BrokerAbi::current(); let req_cache = requester.cache.clone(); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\propagate.rs:553: .collect(); let mut req_brain = connect_retry(&v.name); - let conn = req_brain.net_dial(addr, Some(MintedOp::new(Minter::Cli, op()))).expect("dial"); + let conn = req_brain + .net_dial(addr, Some(MintedOp::new(Minter::Cli, op()))) + .expect("dial"); let open_op = op(); let running = BrokerAbi::current(); let pol = policy(5); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\propagate.rs:640: .collect(); let mut req_brain = connect_retry(&requester.name); - let conn = req_brain.net_dial(addr, Some(MintedOp::new(Minter::Cli, op()))).expect("dial"); + let conn = req_brain + .net_dial(addr, Some(MintedOp::new(Minter::Cli, op()))) + .expect("dial"); let asker = thread::spawn(move || request_update_status(&mut req_brain, conn.conn_id)); let (stream, origin) = wait_for_stream_except(&mut serve_brain, &skip); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\psyche_context_file_e2e.rs:110: fn seed_bound_perch(id: &str, session_id: &str) { let path = perch::resolve_perch_path(id, ParentHint::Infer); std::fs::create_dir_all(&path).unwrap(); - let mut rec = InfoJson::new(id, "2026-06-01T00:00:00Z", std::process::id(), session_id, "live_agent"); + let mut rec = InfoJson::new( + id, + "2026-06-01T00:00:00Z", + std::process::id(), + session_id, + "live_agent", + ); rec.status = Some(STATUS_ONLINE.to_string()); rec.controllable = Some(true); info::write_info(&path, &rec).unwrap(); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\psyche_context_file_e2e.rs:166: std::fs::write(&gate, "").unwrap(); let report = host.pulse_tick(Some(sid)).expect("first pulse tick"); assert!(report.echo_fired, "the armed gate fired the first turn"); - assert_eq!(report.turn_outcome, Some(Ok(())), "the first turn ran cleanly (non-empty stdout)"); + assert_eq!( + report.turn_outcome, + Some(Ok(())), + "the first turn ran cleanly (non-empty stdout)" + ); assert!( wait_until(Duration::from_secs(10), || proof.exists()), Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\psyche_event_turn_e2e.rs:133: // ephemeral model does not). This is the structural "no resident" discriminator // (`is_perch_alive` reads an ABSENT perch as alive — interim parity — so it is // NOT the probe here). - let psyche_perch = - perch::resolve_perch_path(&format!("{id}-psyche"), ParentHint::Explicit(id)); + let psyche_perch = perch::resolve_perch_path(&format!("{id}-psyche"), ParentHint::Explicit(id)); assert!( !psyche_perch.join("info.json").exists(), "no {{id}}-psyche perch is bound by a per-event turn (RED if a resident spawn is re-added)" Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\psyche_event_turn_e2e.rs:164: // An online live_agent perch with the adapter set — reconcile hosts it. let perch_path = perch::resolve_perch_path(id, ParentHint::Infer); std::fs::create_dir_all(&perch_path).unwrap(); - let mut rec = spt_store::info::InfoJson::new(id, "t", std::process::id(), "sid-1", "live_agent"); + let mut rec = + spt_store::info::InfoJson::new(id, "t", std::process::id(), "sid-1", "live_agent"); rec.adapter = Some("mock".to_string()); spt_store::info::write_info(&perch_path, &rec).unwrap(); spt_store::info::set_status(&perch_path, STATUS_ONLINE).unwrap(); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\psyche_event_turn_e2e.rs:184: &cfg, StartReason::Cold, ); - assert_eq!(set.len(), 1, "the online live endpoint is hosted (pulse loop started)"); + assert_eq!( + set.len(), + 1, + "the online live endpoint is hosted (pulse loop started)" + ); // The host spawned NO resident psyche: the nested perch is never a live process. // (RED if host_one re-adds the retired spawn_psyche_owned resident spawn.) Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\psyche_event_turn_e2e.rs:191: - let psyche_perch = - perch::resolve_perch_path(&format!("{id}-psyche"), ParentHint::Explicit(id)); + let psyche_perch = perch::resolve_perch_path(&format!("{id}-psyche"), ParentHint::Explicit(id)); // Give any (erroneously re-added) resident spawn a moment to bind its perch, then // assert none was bound (info.json absent = no resident — see leg 1's note). - let never_resident = - !wait_until(Duration::from_secs(2), || psyche_perch.join("info.json").exists()); + let never_resident = !wait_until(Duration::from_secs(2), || { + psyche_perch.join("info.json").exists() + }); // Tear down the driver thread via the public un-host path (flip offline → // reconcile un-hosts + joins) so the tempdir cleanup does not race a live loop. Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\psyche_residency_expectation_e2e.rs:177: ) }; run_reconcile(); - assert_eq!(set.len(), 1, "the online live endpoint is hosted (pulse driver started)"); + assert_eq!( + set.len(), + 1, + "the online live endpoint is hosted (pulse driver started)" + ); // Drive the failing turns: re-arm the echo gate repeatedly (the driver consumes it // each fire), until several turns have fired AND the fault stamp has landed. Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\psyche_residency_expectation_e2e.rs:214: ); // The budget stamped the fault on the PARENT — psyche fields only. - assert!(stamped, "the turn-failure budget must stamp psyche_host_error on the parent"); + assert!( + stamped, + "the turn-failure budget must stamp psyche_host_error on the parent" + ); let info = spt_store::info::read_info(&perch_path).expect("parent perch readable"); assert!( info.psyche_host_error.is_some(), Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\psyche_residency_expectation_e2e.rs:234: // (1) still HOSTED (no un-host churn), (2) still ONLINE (deliverable), (3) ready // marker still PRESENT. A resident-model teardown (the deleted v0.13.2 shape) would // fail all three — that is the RED-first guard-revert. - assert_eq!(set.len(), 1, "the endpoint is NOT un-hosted (no rehost churn)"); assert_eq!( + set.len(), + 1, + "the endpoint is NOT un-hosted (no rehost churn)" + ); + assert_eq!( info.status.as_deref(), Some(STATUS_ONLINE), "the parent stays ONLINE (deliverable) — psyche trouble never de-stamps status" Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\psyche_residency_expectation_e2e.rs:250: // FAILING PSYCHE never triggered it above). spt_store::info::set_status(&perch_path, spt_store::liveness::STATUS_OFFLINE).unwrap(); run_reconcile(); - assert!(set.is_empty(), "an offline-transitioned endpoint IS un-hosted (the legit path)"); + assert!( + set.is_empty(), + "an offline-transitioned endpoint IS un-hosted (the legit path)" + ); std::env::remove_var("SPT_PSYCHE_TURN_STRIKE_BUDGET"); } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\pumpdeadline.rs:18: use spt_daemon::brain::Brain; use spt_daemon::codec::read_frame; -use spt_daemon::transport::{recv_hello, DaemonTransport, LocalSocketTransport}; use spt_daemon::frame::Role; +use spt_daemon::transport::{recv_hello, DaemonTransport, LocalSocketTransport}; static SEQ: AtomicU32 = AtomicU32::new(0); fn unique_name() -> String { Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\pumpdeadline.rs:58: // then drop it (unblocking the client's reader thread to exit cleanly). thread::sleep(timeout * 3); }); - let mut brain = - Brain::cold_start_pump(&name, 0, timeout).expect("connect pump-mode brain"); + let mut brain = Brain::cold_start_pump(&name, 0, timeout).expect("connect pump-mode brain"); let started = Instant::now(); let err = brain Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\replicate.rs:21: use std::time::Duration; use spt_daemon::brain::{Brain, BrokerEvent}; -use spt_daemon::effect::{Minter, MintedOp}; +use spt_daemon::effect::{MintedOp, Minter}; use spt_daemon::nethost::{NetConfig, NetHost}; use spt_daemon::Broker; use spt_net::net::endpoint::{BindScope, LocalDiscovery, RelayPolicy}; Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\replicate.rs:174: // ── The wire: dial B, open a stream, send the feed (journaled ops). ───── let mut b_probe = connect_retry(&name_b); let addr = b_probe.net_status().expect("b status").addr; - let conn = sender.net_dial(addr, Some(MintedOp::new(Minter::Cli, 1))).expect("dial"); - let opened = sender.net_open_stream(conn.conn_id, Some(MintedOp::new(Minter::Cli, 2))).expect("open"); + let conn = sender + .net_dial(addr, Some(MintedOp::new(Minter::Cli, 1))) + .expect("dial"); + let opened = sender + .net_open_stream(conn.conn_id, Some(MintedOp::new(Minter::Cli, 2))) + .expect("open"); // Send 1: the Active row, split MID-RECORD across two separate sends — // the receiver's decoder, not QUIC chunk shape, owns record framing. Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\replicate.rs:182: let line = update_active.encode_line(); let split = line.len() / 2; sender - .net_stream_send(opened.stream_id, &line[..split], Some(MintedOp::new(Minter::Cli, 100)), false) + .net_stream_send( + opened.stream_id, + &line[..split], + Some(MintedOp::new(Minter::Cli, 100)), + false, + ) .expect("send first half"); sender - .net_stream_send(opened.stream_id, &line[split..], Some(MintedOp::new(Minter::Cli, 101)), false) + .net_stream_send( + opened.stream_id, + &line[split..], + Some(MintedOp::new(Minter::Cli, 101)), + false, + ) .expect("send second half"); // Send 2: the newer Offline. Send 3: the e1 Active REPLAYED (a lagging // duplicate arriving late) — the lease must drop it at B. Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\reseed.rs:14: use std::time::Duration; use spt_daemon::nethost::{NetConfig, NetHost}; -use spt_daemon::seedproofx::{ - MemberStatus, MembershipSource, RosterExchange, SubnetCred, -}; +use spt_daemon::seedproofx::{MemberStatus, MembershipSource, RosterExchange, SubnetCred}; use spt_net::net::endpoint::{BindScope, LocalDiscovery, RelayPolicy}; use spt_proto::identity::Identity; Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\reseed.rs:59: } }), adopt_seed: Arc::new(move |subnet: &str, s: &[u8], epoch: u64| { - adopted.lock().unwrap().push((subnet.to_string(), s.to_vec(), epoch)); + adopted + .lock() + .unwrap() + .push((subnet.to_string(), s.to_vec(), epoch)); true }), } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\reseed.rs:123: "the offliner received a seed push" ); let pushed = b_adopt.lock().unwrap().clone(); - assert_eq!(pushed, vec![("home".to_string(), seed(2), 2)], "current seed adopted"); + assert_eq!( + pushed, + vec![("home".to_string(), seed(2), 2)], + "current seed adopted" + ); // A re-seeds, it does not pull one (it is the fresh side): nothing adopted. - assert!(a_adopt.lock().unwrap().is_empty(), "the fresh node adopts nothing"); + assert!( + a_adopt.lock().unwrap().is_empty(), + "the fresh node adopts nothing" + ); // A registered the conn only to deliver the seed — it is re-seed-only, so it // proves NO subnet (it serves nothing; it is replaced when B reconnects full). Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\reseed.rs:133: - assert!(wait_until(|| a.conn_count() == 1), "conn kept alive for delivery"); + assert!( + wait_until(|| a.conn_count() == 1), + "conn kept alive for delivery" + ); assert!( a.conn_proven_subnets(1).is_empty(), "a re-seed-only conn carries no proven subnet" Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\rosterprop.rs:48: let sink_store = Arc::clone(&store); let status_store = Arc::clone(&store); RosterExchange { - provider: Arc::new(move |proven: &HashSet, self_addr: &serde_json::Value| { - let mut s = prov_store.lock().unwrap(); - let addr = if self_addr.is_null() { - None - } else { - Some(self_addr.clone()) - }; - for subnet in proven { - s.upsert_self(subnet, &self_hex, "lbl", "mid", addr.clone(), "1700000000", 5); - } - let mut entries = Vec::new(); - let mut tombs = Vec::new(); - for subnet in proven { - let (m, t) = s.roster_for(subnet); - entries.extend(m); - tombs.extend(t); - } - (entries, tombs) - }), + provider: Arc::new( + move |proven: &HashSet, self_addr: &serde_json::Value| { + let mut s = prov_store.lock().unwrap(); + let addr = if self_addr.is_null() { + None + } else { + Some(self_addr.clone()) + }; + for subnet in proven { + s.upsert_self( + subnet, + &self_hex, + "lbl", + "mid", + addr.clone(), + "1700000000", + 5, + ); + } + let mut entries = Vec::new(); + let mut tombs = Vec::new(); + for subnet in proven { + let (m, t) = s.roster_for(subnet); + entries.extend(m); + tombs.extend(t); + } + (entries, tombs) + }, + ), sink: Arc::new(move |entries, tombs| { let mut s = sink_store.lock().unwrap(); for e in &entries { Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\sync.rs:28: use std::time::Duration; use spt_daemon::brain::{Brain, BrokerEvent}; -use spt_daemon::effect::{Minter, MintedOp}; +use spt_daemon::effect::{MintedOp, Minter}; use spt_daemon::nethost::{NetConfig, NetHost}; use spt_daemon::sync::{ reconcile_after_sync, request_sync, serve_sync, ReconcileWiring, SyncPolicy, SyncServeOutcome, Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\sync.rs:183: .collect(); let mut req_brain = connect_retry(&self.requester); - let conn = req_brain.net_dial(addr, Some(MintedOp::new(Minter::Cli, op()))).expect("dial"); + let conn = req_brain + .net_dial(addr, Some(MintedOp::new(Minter::Cli, op()))) + .expect("dial"); let refs_owned: Vec = refs.iter().map(|r| r.to_string()).collect(); let req_root = self.requester_root.clone(); let scratch_req = self.scratch.join("req"); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\sync.rs:548: let mut serve_brain = connect_retry(&name_a); let addr = serve_brain.net_status().unwrap().addr; let mut req_brain = connect_retry(&name_b); - let conn = req_brain.net_dial(addr, Some(MintedOp::new(Minter::Cli, op()))).expect("dial"); + let conn = req_brain + .net_dial(addr, Some(MintedOp::new(Minter::Cli, op()))) + .expect("dial"); let root_b_clone = root_b.clone(); let scratch_req = scratch.join("req"); let open_op = MintedOp::new(Minter::Pump, op()); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\two_origin_spanning.rs:129: }; let mut keys = BTreeMap::new(); keys.insert("session_id".to_string(), "A".to_string()); - let echo = fetch_history(&history, &keys, "cc", ParentHint::Infer, Duration::from_secs(10)) - .expect("history fetch"); + let echo = fetch_history( + &history, + &keys, + "cc", + ParentHint::Infer, + Duration::from_secs(10), + ) + .expect("history fetch"); assert_eq!(echo.len(), 1); assert!( echo[0].raw.contains("FULL-FIDELITY-A"), Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\two_origin_spanning.rs:140: // ── Consumer 2: the digest reads [digest] CONTRACT, spanned + merged ──────── let digest = project_endpoint_digest("cc", &DigestOverride::default()); - let inputs: Vec<_> = digest.turns.iter().filter_map(|t| t.input.as_deref()).collect(); + let inputs: Vec<_> = digest + .turns + .iter() + .filter_map(|t| t.input.as_deref()) + .collect(); assert_eq!( inputs, vec!["before clear", "after clear"], Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\two_origin_spanning.rs:149: // A /clear boundary divider separates the sessions (REQ-TERM-6). assert!( - digest.turns.iter().any(|t| t.entries.iter().any(|e| matches!( - e, - DigestEntry::Boundary { kind, .. } if kind == "clear" - ))), + digest + .turns + .iter() + .any(|t| t.entries.iter().any(|e| matches!( + e, + DigestEntry::Boundary { kind, .. } if kind == "clear" + ))), "a /clear boundary marker is present" ); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\two_origin_spanning.rs:184: !rendered.contains("FULL-FIDELITY"), "the digest is contract-typed (extra adapter fields ignored): {rendered}" ); - assert!(rendered.contains("── /clear ──"), "boundary renders distinctively: {rendered}"); + assert!( + rendered.contains("── /clear ──"), + "boundary renders distinctively: {rendered}" + ); } // [int->REQ-DIGEST-GENERATION-SUPERSEDE] the flynn digest gen-union rig, end to Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\two_origin_spanning.rs:265: // windowing: without supersede the span carries FIVE input turns // (a-one, a-two, [clear], a-one, a-two, b-tail) and all survive the window — // RED. With supersede the ancestor's two rows collapse into B's generation. - let over = DigestOverride { window_turns: Some(10), ..Default::default() }; + let over = DigestOverride { + window_turns: Some(10), + ..Default::default() + }; let digest = project_endpoint_digest("ccgen", &over); - let inputs: Vec<_> = digest.turns.iter().filter_map(|t| t.input.as_deref()).collect(); + let inputs: Vec<_> = digest + .turns + .iter() + .filter_map(|t| t.input.as_deref()) + .collect(); assert_eq!( inputs, vec!["a-one", "a-two", "b-tail"], Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\two_origin_spanning.rs:276: // Gen A fully superseded (all rows replayed into B) → its /clear divider is // orphaned and trimmed (rule 5: a divider sits only between ≥1-row sessions). assert!( - !digest - .turns + !digest.turns.iter().any(|t| t + .entries .iter() - .any(|t| t.entries.iter().any(|e| matches!( - e, - DigestEntry::Boundary { .. } - ))), + .any(|e| matches!(e, DigestEntry::Boundary { .. }))), "no orphaned /clear divider once the replayed ancestor is emptied: {:?}", digest.turns ); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\twohost.rs:60: use spt_daemon::brain::Brain; use spt_daemon::broker::Broker; -use spt_daemon::effect::{Minter, MintedOp}; use spt_daemon::dispatch::{run_dispatch_loop, DispatchPaths}; +use spt_daemon::effect::{MintedOp, Minter}; use spt_daemon::nethost::{NetConfig, NetHost}; use spt_daemon::pump::{ run_peer_pump, PeerResolver, PumpCadence, PumpConfig, PumpHooks, PumpPaths, Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\twohost.rs:81: use spt_store::info::{self, InfoJson}; use spt_store::notif::{NotifRow, NotifStore}; use spt_store::perch::{self, ParentHint}; +use spt_store::roster::RosterStore; use spt_store::spool; use spt_store::subnet::SubnetStore; -use spt_store::roster::RosterStore; use spt_store::visibility::VisibilityStore; use tempfile::TempDir; Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\twohost.rs:552: Some(DRIVE_TGT_ALIAS), ) .expect("mint agent-owned offdrive"); - let g = - spt_store::shellinfo::spawn_record(&perch::owlery_dir(), GW_OWNER, "offdrive", Some(GW_ALIAS)) - .expect("mint gateway-owned offdrive"); + let g = spt_store::shellinfo::spawn_record( + &perch::owlery_dir(), + GW_OWNER, + "offdrive", + Some(GW_ALIAS), + ) + .expect("mint gateway-owned offdrive"); println!("TWOHOST role B: offline drive shells minted — {ID_B}/{a}, {GW_OWNER}/{g}"); } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\twohost.rs:841: rig.wait, || { spool::peek_all_at(&gw_perch) - .map(|rows| rows.iter().any(|(_, _, body, _)| body.contains("op=\"press\""))) + .map(|rows| { + rows.iter() + .any(|(_, _, body, _)| body.contains("op=\"press\"")) + }) .unwrap_or(false) }, ); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\twohost.rs:859: // ordinary wire rest op. The durable rest record is the same observable // rung 8 proved; what is NEW is the bare-id ROUTE that produced the wake // (A asserts the routing decision on its side). - rig_wait("A-3: A's setup suspend landed (B suspended)", rig.wait, || { - spt_daemon::resting::read_rest(&perch_b) - .map(|r| r.state == spt_daemon::resting::RestState::Suspended) - .unwrap_or(false) - }); + rig_wait( + "A-3: A's setup suspend landed (B suspended)", + rig.wait, + || { + spt_daemon::resting::read_rest(&perch_b) + .map(|r| r.state == spt_daemon::resting::RestState::Suspended) + .unwrap_or(false) + }, + ); // [int->REQ-REST-VERB-ROUTING] - rig_wait("A-3: A's bare-id ROUTED wake landed (B active)", rig.wait, || { - spt_daemon::resting::read_rest(&perch_b) - .map(|r| r.state == spt_daemon::resting::RestState::Active) - .unwrap_or(false) - }); + rig_wait( + "A-3: A's bare-id ROUTED wake landed (B active)", + rig.wait, + || { + spt_daemon::resting::read_rest(&perch_b) + .map(|r| r.state == spt_daemon::resting::RestState::Active) + .unwrap_or(false) + }, + ); info::set_last_active(&perch_b, now_ms()).expect("re-stamp B's recency post-A-3"); println!("TWOHOST OK: A-3 bare-id wake (serve side)"); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\twohost.rs:916: // The child's control attach stamps the perch on this broker's sessions-poll // converge (KH 7.29) — polling in the probe IS the production trigger (the // reconcile tick's query_live_session_endpoints). - rig_wait("B-2: the attacher child's control stamps landed", rig.wait, || { - let _ = host_brain.sessions(); - info::read_info(&perch_b2).is_some_and(|i| i.controlled && i.driven_by.is_some()) - }); + rig_wait( + "B-2: the attacher child's control stamps landed", + rig.wait, + || { + let _ = host_brain.sessions(); + info::read_info(&perch_b2).is_some_and(|i| i.controlled && i.driven_by.is_some()) + }, + ); // Signal A (store-state, the rung-7 replication pattern): stamps seen — // A kills the child on this row's arrival. store_b Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\twohost.rs:939: // sink is reaped on a sessions poll and the stamps CLEAR — the exact field // outcome B-2 exists for (a stale ONLINE+CONTROLLED that never healed). // [int->REQ-CONTROLLER-LIVENESS-REAP] - rig_wait("B-2: the severed controller's stamps CLEAR (reap + converge)", rig.wait, || { - let _ = host_brain.sessions(); - info::read_info(&perch_b2).is_some_and(|i| !i.controlled && i.driven_by.is_none()) - }); + rig_wait( + "B-2: the severed controller's stamps CLEAR (reap + converge)", + rig.wait, + || { + let _ = host_brain.sessions(); + info::read_info(&perch_b2).is_some_and(|i| !i.controlled && i.driven_by.is_none()) + }, + ); println!("TWOHOST OK: B-2 dead-controller reap cleared the stamps"); // ── Hold until A finishes its side (it pushes the done-file as its last Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\twohost.rs:1075: // [int->REQ-NET-1] let mut a = connect_retry(&broker_name); let conn = a - .net_dial(rig.peer_broker_addr("a"), Some(MintedOp::new(Minter::Cli, op()))) + .net_dial( + rig.peer_broker_addr("a"), + Some(MintedOp::new(Minter::Cli, op())), + ) .expect("dial B"); let opened = a .net_open_stream(conn.conn_id, Some(MintedOp::new(Minter::Cli, op()))) Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\twohost.rs:1128: println!("TWOHOST OK: file fetch (sid {sid})"); // [int->REQ-INST-8] - let viewport = - spt_daemon::attach::request_attach(&mut a, conn.conn_id, sid, 0, MintedOp::new(Minter::Rc, op()), spt_net::net::attach::AttachIntent::Control).expect("attach"); + let viewport = spt_daemon::attach::request_attach( + &mut a, + conn.conn_id, + sid, + 0, + MintedOp::new(Minter::Rc, op()), + spt_net::net::attach::AttachIntent::Control, + ) + .expect("attach"); a.net_stream_subscribe(viewport, 0) .expect("subscribe viewport"); spt_daemon::attach::send_attach_input( Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\twohost.rs:1502: "A-3 setup suspend applied an edge at B: {out:?}" ); rig_wait("A-3: B advertises Suspended at A", rig.wait, || { - registry.rows(&rig.subnet, ID_B).iter().any(|i| { - i.node == rig.b_hex() && i.status == spt_net::net::registry::Status::Suspended - }) + registry + .rows(&rig.subnet, ID_B) + .iter() + .any(|i| i.node == rig.b_hex() && i.status == spt_net::net::registry::Status::Suspended) }); // The PRODUCTION routing decision (red = the pre-fix local-only WOKE_FAIL). // [int->REQ-REST-VERB-ROUTING] Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\twohost.rs:1546: "A-3 routed wake applied an edge at B: {out:?}" ); rig_wait("A-3: B advertises Active again at A", rig.wait, || { - registry.rows(&rig.subnet, ID_B).iter().any(|i| { - i.node == rig.b_hex() && i.status == spt_net::net::registry::Status::Active - }) + registry + .rows(&rig.subnet, ID_B) + .iter() + .any(|i| i.node == rig.b_hex() && i.status == spt_net::net::registry::Status::Active) }); println!("TWOHOST OK: A-3 bare-id wake routed via the production assembly"); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\wake_single_flight.rs:47: static SEQ: AtomicU32 = AtomicU32::new(0); fn unique_name() -> String { let n = SEQ.fetch_add(1, Ordering::Relaxed); - format!("spt-daemon-wakesingleflight-{}-{}.sock", std::process::id(), n) + format!( + "spt-daemon-wakesingleflight-{}-{}.sock", + std::process::id(), + n + ) } fn kill_pid(pid: u32) { Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\wake_single_flight.rs:109: let mut c = connect(name); let req = sleeper_spawn_req(endpoint); barrier.wait(); // both wakes cross this line together → concurrent dispatch_spawn - write_frame(&mut c, &Envelope::new(KIND_SPAWN, serde_json::to_value(req).unwrap())) - .expect("send spawn"); + write_frame( + &mut c, + &Envelope::new(KIND_SPAWN, serde_json::to_value(req).unwrap()), + ) + .expect("send spawn"); let sid = loop { match read_frame(&mut c) { Ok(f) if f.kind == KIND_SPAWNED => { Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\wake_single_flight.rs:117: - break serde_json::from_value::(f.payload).unwrap().session_id + break serde_json::from_value::(f.payload) + .unwrap() + .session_id } Ok(_) => continue, Err(e) => panic!("wake read failed: {e}"), Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\wake_single_flight.rs:157: } } - eprintln!("=== W4 SINGLE-FLIGHT WAKE: sid1={sid1} sid2={sid2} session_count={session_count} ==="); + eprintln!( + "=== W4 SINGLE-FLIGHT WAKE: sid1={sid1} sid2={sid2} session_count={session_count} ===" + ); // Exactly one launch tree: both wakes resolved to the SAME session (the second // deduped to the first), and the broker holds exactly one session. Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\wanmsg.rs:23: use std::time::Duration; use spt_daemon::brain::{Brain, BrokerEvent}; -use spt_daemon::effect::{Minter, MintedOp}; +use spt_daemon::effect::{MintedOp, Minter}; use spt_daemon::nethost::{NetConfig, NetHost}; use spt_daemon::registryhost::RegistryHost; use spt_daemon::wan::{receive_wan, WanOutcome}; Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\wanmsg.rs:229: .expect("node id"); let mut b_probe = connect_retry(&name_b); let addr = b_probe.net_status().expect("b status").addr; - let conn = sender.net_dial(addr, Some(MintedOp::new(Minter::Cli, 1))).expect("dial"); - let opened = sender.net_open_stream(conn.conn_id, Some(MintedOp::new(Minter::Cli, 2))).expect("open"); + let conn = sender + .net_dial(addr, Some(MintedOp::new(Minter::Cli, 1))) + .expect("dial"); + let opened = sender + .net_open_stream(conn.conn_id, Some(MintedOp::new(Minter::Cli, 2))) + .expect("open"); // Record 1, split MID-RECORD across two separate sends. let m1 = msg(&target, "hello across the wire", "a:1"); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\wanmsg.rs:237: let line = m1.encode_line(); let split = line.len() / 2; sender - .net_stream_send(opened.stream_id, &line[..split], Some(MintedOp::new(Minter::Cli, 100)), false) + .net_stream_send( + opened.stream_id, + &line[..split], + Some(MintedOp::new(Minter::Cli, 100)), + false, + ) .expect("send"); sender - .net_stream_send(opened.stream_id, &line[split..], Some(MintedOp::new(Minter::Cli, 101)), false) + .net_stream_send( + opened.stream_id, + &line[split..], + Some(MintedOp::new(Minter::Cli, 101)), + false, + ) .expect("send"); // Record 2: a FORGED origin_node riding inside the JSON (the anti-spoof // negative: it must decode as an ignored unknown field). Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\wanmsg.rs:248: "{{\"target\":\"{target}\",\"from\":\"mallory\",\"body\":\"spoofed?\",\"op_id\":\"a:2\",\"origin_node\":\"evil\"}}\n" ); sender - .net_stream_send(opened.stream_id, forged.as_bytes(), Some(MintedOp::new(Minter::Cli, 102)), false) + .net_stream_send( + opened.stream_id, + forged.as_bytes(), + Some(MintedOp::new(Minter::Cli, 102)), + false, + ) .expect("send"); // Record 3: record 1 REPLAYED (same wire op_id — a lagging duplicate). sender Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\wanmsg.rs:255: - .net_stream_send(opened.stream_id, &m1.encode_line(), Some(MintedOp::new(Minter::Cli, 103)), true) + .net_stream_send( + opened.stream_id, + &m1.encode_line(), + Some(MintedOp::new(Minter::Cli, 103)), + true, + ) .expect("send"); // ── Node B: subscribe, decode, funnel — under the handshake origin. ───── Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\wanmsg.rs:306: let mut sender = connect_retry(&name_a); let mut b_probe = connect_retry(&name_b); let addr = b_probe.net_status().expect("b status").addr; - let conn = sender.net_dial(addr, Some(MintedOp::new(Minter::Cli, 1))).expect("dial"); - let opened = sender.net_open_stream(conn.conn_id, Some(MintedOp::new(Minter::Cli, 2))).expect("open"); + let conn = sender + .net_dial(addr, Some(MintedOp::new(Minter::Cli, 1))) + .expect("dial"); + let opened = sender + .net_open_stream(conn.conn_id, Some(MintedOp::new(Minter::Cli, 2))) + .expect("open"); for n in 0..3u64 { let m = msg(&target, &format!("msg-{n}"), &format!("a:{n}")); sender Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\wanmsg.rs:314: - .net_stream_send(opened.stream_id, &m.encode_line(), Some(MintedOp::new(Minter::Cli, 100 + n)), n == 2) + .net_stream_send( + opened.stream_id, + &m.encode_line(), + Some(MintedOp::new(Minter::Cli, 100 + n)), + n == 2, + ) .expect("send"); } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\xfer.rs:22: use std::time::Duration; use spt_daemon::brain::{Brain, BrokerEvent}; -use spt_daemon::effect::{Minter, MintedOp}; +use spt_daemon::effect::{MintedOp, Minter}; use spt_daemon::nethost::{NetConfig, NetHost}; use spt_daemon::xfer::{fetch_file, push_file, serve_xfer, XferServeOutcome}; use spt_daemon::Broker; Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\xfer.rs:120: .expect("b status") .node_id_hex .expect("node id"); - let conn = operator.net_dial(a_addr, Some(MintedOp::new(Minter::Cli, 1))).expect("dial"); + let conn = operator + .net_dial(a_addr, Some(MintedOp::new(Minter::Cli, 1))) + .expect("dial"); let dest = dir.path().join("fetched").join("plan.md"); let dest_clone = dest.clone(); let progress_b_clone = progress_b.clone(); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\xfer.rs:186: // Confinement: a traversal fetch is refused with an Err record (the // operator's fetch errors; nothing outside the root is served). let conn2 = operator - .net_dial(target.net_status().expect("a").addr, Some(MintedOp::new(Minter::Cli, 3))) + .net_dial( + target.net_status().expect("a").addr, + Some(MintedOp::new(Minter::Cli, 3)), + ) .expect("dial2"); let dest2 = dir.path().join("stolen.txt"); let fetcher2 = thread::spawn(move || { Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-daemon\tests\xfer.rs:252: // Operator B: push on its own thread; it blocks until the commit echo — // which only the successor brain will send. let mut operator = connect_retry(&name_b); - let conn = operator.net_dial(a_addr, Some(MintedOp::new(Minter::Cli, 1))).expect("dial"); + let conn = operator + .net_dial(a_addr, Some(MintedOp::new(Minter::Cli, 1))) + .expect("dial"); let total = bytes.len() as u64; let pusher = thread::spawn(move || { push_file( Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\manifest.rs:114: // [impl->REQ-ADAPTER-FLOOR-ENFORCE] pub fn version_meets_floor(core: &str, floor: &str) -> bool { let parts = |s: &str| -> Vec { - s.split('.').map(|c| c.trim().parse::().unwrap_or(0)).collect() + s.split('.') + .map(|c| c.trim().parse::().unwrap_or(0)) + .collect() }; let (c, f) = (parts(core), parts(floor)); let n = c.len().max(f.len()); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\manifest.rs:121: for i in 0..n { - let (cv, fv) = (c.get(i).copied().unwrap_or(0), f.get(i).copied().unwrap_or(0)); + let (cv, fv) = ( + c.get(i).copied().unwrap_or(0), + f.get(i).copied().unwrap_or(0), + ); if cv != fv { return cv > fv; // core > floor at the first differing component ⇒ satisfied } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\manifest.rs:1152: // Dead config: warn on an unfillable key, refuse nothing. let dead: Vec = crate::runtime::placeholder_keys(&role.command) .into_iter() - .chain(role.cwd.iter().flat_map(|c| crate::runtime::placeholder_keys(c))) + .chain( + role.cwd + .iter() + .flat_map(|c| crate::runtime::placeholder_keys(c)), + ) .chain(role.keys.iter().cloned()) .filter(|k| !crate::runtime::is_fillable_key_for_role(role_name, k)) .collect(); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\manifest.rs:1354: assert_eq!(m.env["OWL_SESSION_ID"].direction, EnvDirection::Inject); // digest: the extractor seam with own source + presentation defaults let dig = m.digest.as_ref().unwrap(); - assert_eq!(dig.extractor, "claude-spt-digest --session {session_id} --in {source}"); + assert_eq!( + dig.extractor, + "claude-spt-digest --session {session_id} --in {source}" + ); assert_eq!(dig.window_turns, Some(5)); assert_eq!(dig.arg_truncation, Some(40)); assert_eq!(dig.sprint_collapse, Some(true)); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\manifest.rs:1418: let u = m.update.clone().unwrap(); assert_eq!(u.avenue, UpdateAvenue::GhRelease); assert_eq!(u.repo.as_deref(), Some("user/repo")); - assert!(u.asset.is_none(), "asset is optional (defaults to adapter.spt)"); - assert!(u.signing_key.is_none(), "signing_key is optional for gh_release"); + assert!( + u.asset.is_none(), + "asset is optional (defaults to adapter.spt)" + ); + assert!( + u.signing_key.is_none(), + "signing_key is optional for gh_release" + ); let reparsed = Manifest::from_toml_str(&m.to_toml_string().unwrap()).unwrap(); assert_eq!(m.update, reparsed.update, "gh_release round-trips"); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\manifest.rs:1488: // tunnel's opaque wire). #[test] fn shell_tunnel_opt_in() { - let base = "[adapter]\nname=\"u\"\nkind=\"shell\"\nversion=\"1\"\nmin_spt_core_version=\"1\"\n\n\ + let base = + "[adapter]\nname=\"u\"\nkind=\"shell\"\nversion=\"1\"\nmin_spt_core_version=\"1\"\n\n\ [shell]\nspawn=\"usbip-shell --link {link_token}\"\n"; // enabled + labelled → parses, fields preserved, round-trips. Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\manifest.rs:1560: .contains("message-idle-translation-binary")); // declared with an empty path → refused at validate. - let empty = - format!("{base}\n[message-idle-translation-binary]\npath = \"\"\n"); + let empty = format!("{base}\n[message-idle-translation-binary]\npath = \"\"\n"); let err = Manifest::from_toml_str(&empty).unwrap_err().to_string(); assert!( err.contains("message-idle-translation-binary") && err.contains("non-empty"), Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\manifest.rs:1619: ); // empty command → refused. - let empty = - format!("{base}\n[message-idle-translation-binary]\ncommand = \"\"\n"); + let empty = format!("{base}\n[message-idle-translation-binary]\ncommand = \"\"\n"); let err = Manifest::from_toml_str(&empty).unwrap_err().to_string(); assert!( err.contains("`command` must be non-empty"), Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\manifest.rs:1671: ); // is_empty() is false when ONLY resume is declared (no self, no dirs). - let resume_only = format!( - "{base}\n[session.resume]\ncommand = 'claude -r {{session_id}}'\n" - ); + let resume_only = + format!("{base}\n[session.resume]\ncommand = 'claude -r {{session_id}}'\n"); let mr = Manifest::from_toml_str(&resume_only).expect("resume-only parses"); assert!( !mr.session.is_empty(), Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\manifest.rs:1684: // Round-trip: parse → emit → reparse is stable for the resume role. let reparsed = Manifest::from_toml_str(&m.to_toml_string().unwrap()).unwrap(); - assert_eq!(m.session.resume, reparsed.session.resume, "resume round-trips"); + assert_eq!( + m.session.resume, reparsed.session.resume, + "resume round-trips" + ); let emitted = m.to_toml_string().unwrap(); assert!( emitted.contains("[session.resume]"), Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\manifest.rs:1693: // BACK-COMPAT: a manifest with [session.self] but NO [session.resume] // parses with resume == None (an old adapter is unaffected). - let no_resume = format!( - "{base}\n[session.self]\ncommand = 'claude --session-id {{session_id}}'\n" - ); + let no_resume = + format!("{base}\n[session.self]\ncommand = 'claude --session-id {{session_id}}'\n"); let m0 = Manifest::from_toml_str(&no_resume).expect("no-resume parses"); assert!(m0.session.self_.is_some()); assert!( Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\manifest.rs:1840: regex: false, }; // Case-insensitive substring; returns the matched keyword. - assert_eq!(literal.matched_keyword("how do i spt send a msg"), Some("SPT send")); + assert_eq!( + literal.matched_keyword("how do i spt send a msg"), + Some("SPT send") + ); assert_eq!(literal.matched_keyword("the OWL hoots"), Some("owl")); assert_eq!(literal.matched_keyword("nothing here"), None); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\manifest.rs:1851: regex: true, }; assert_eq!(re.matched_keyword("run spt send now"), Some(r"spt\s+\w+")); - assert!(re.matched_keyword("sptsend").is_none(), "regex needs the whitespace"); + assert!( + re.matched_keyword("sptsend").is_none(), + "regex needs the whitespace" + ); // An invalid regex matches nothing (best-effort, never panics). let bad = Hint { Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\manifest.rs:1875: .expect("parses"); assert_eq!(parent.hints.len(), 1); let merged = crate::profile::resolve(&parent, "p").expect("resolves"); - assert_eq!(merged.hints.len(), 1, "array replaced wholesale, not spliced"); + assert_eq!( + merged.hints.len(), + 1, + "array replaced wholesale, not spliced" + ); assert_eq!(merged.hints[0].text, "profile hint"); } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\manifest.rs:2027: "#; let e = Manifest::from_toml_str(no_src).unwrap_err(); assert!(matches!(e, ManifestError::Validation(_))); - assert!(e.to_string().contains("source") || e.to_string().contains("locate_template"), "{e}"); + assert!( + e.to_string().contains("source") || e.to_string().contains("locate_template"), + "{e}" + ); // Zero window. let zero = r#" Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\manifest.rs:2172: #[test] fn version_meets_floor_numeric_not_lexical() { // Equal boundary ⇒ satisfied (floor is at-LEAST, not strictly-newer). - assert!(version_meets_floor("0.25.0", "0.25.0"), "equal meets the floor"); + assert!( + version_meets_floor("0.25.0", "0.25.0"), + "equal meets the floor" + ); // Core strictly above the floor ⇒ satisfied. - assert!(version_meets_floor("0.26.0", "0.25.0"), "core > floor passes"); - assert!(version_meets_floor("1.0.0", "0.9.9"), "major bump clears any minor"); + assert!( + version_meets_floor("0.26.0", "0.25.0"), + "core > floor passes" + ); + assert!( + version_meets_floor("1.0.0", "0.9.9"), + "major bump clears any minor" + ); // Core below the floor ⇒ refused. - assert!(!version_meets_floor("0.24.9", "0.25.0"), "core < floor refused"); + assert!( + !version_meets_floor("0.24.9", "0.25.0"), + "core < floor refused" + ); // The 0.9 < 0.25 trap: a LEXICAL compare says "0.9.0" > "0.25.0" (because '9' > // '2'), which would wrongly PASS a 0.25.0 floor on a 0.9.0 core. Numeric compare Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\manifest.rs:2194: ); // Zero-pad equivalence: a shorter version is right-padded with zeros. - assert!(version_meets_floor("1.0", "1.0.0"), "1.0 == 1.0.0 after zero-pad"); - assert!(version_meets_floor("1.0.0", "1.0"), "and the reverse padding"); + assert!( + version_meets_floor("1.0", "1.0.0"), + "1.0 == 1.0.0 after zero-pad" + ); + assert!( + version_meets_floor("1.0.0", "1.0"), + "and the reverse padding" + ); // The perri repro: a fresh floor bump refuses the older shipped core. assert!( Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\manifest.rs:2246: #[test] fn role_template_is_role_aware_for_notif_extras() { let ok = role_manifest("[session.notif]\ncommand = 'toast {notif_id} {notif_body} {id}'\n"); - assert!(ok.validate_role_templates().is_ok(), "notif extras + base keys fill"); + assert!( + ok.validate_role_templates().is_ok(), + "notif extras + base keys fill" + ); let bad = role_manifest("[session.self]\ncommand = 'run {notif_body}'\n"); let msg = bad.validate_role_templates().unwrap_err().to_string(); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\manifest.rs:2253: - assert!(msg.contains("notif_body"), "a notif-only key is unfillable outside notif: {msg}"); + assert!( + msg.contains("notif_body"), + "a notif-only key is unfillable outside notif: {msg}" + ); } // [unit->REQ-ADAPTER-TEMPLATE-KEY-VALIDATION] a var declared in BOTH a spawned Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\manifest.rs:2303: [session.self]\ncommand = 'run'\n", ); let msg = bad.validate_role_templates().unwrap_err().to_string(); - assert!(msg.contains("gone_key"), "an [env] inject value's dead key refuses: {msg}"); + assert!( + msg.contains("gone_key"), + "an [env] inject value's dead key refuses: {msg}" + ); } } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\profile.rs:289: // [unit->REQ-MANIFEST-2] #[test] fn deep_nested_leaf_replace() { - let base = v("[shell.capabilities.run]\nargs = [\"cmd\"]\n[shell]\nrequire_approval = \"none\""); + let base = + v("[shell.capabilities.run]\nargs = [\"cmd\"]\n[shell]\nrequire_approval = \"none\""); let overlay = v("[shell]\nrequire_approval = \"always\""); let merged = merge_leaf_replace(&base, &overlay); // The capabilities sub-table is untouched; only require_approval flips. Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\profile.rs:333: let parent = Manifest::from_toml_str(PROFILED_SHELL).expect("parent parses"); let merged = resolve(&parent, "work").expect("work resolves"); let shell = merged.shell.expect("merged has shell"); - assert_eq!(shell.require_approval, ShellApproval::Always, "floor tightened"); - assert_eq!(shell.spawn, "run --thing", "untouched leaf survives the merge"); - assert!(merged.profiles.is_empty(), "resolved view drops the profile catalogue"); + assert_eq!( + shell.require_approval, + ShellApproval::Always, + "floor tightened" + ); + assert_eq!( + shell.spawn, "run --thing", + "untouched leaf survives the merge" + ); + assert!( + merged.profiles.is_empty(), + "resolved view drops the profile catalogue" + ); } /// An undeclared profile name is a distinct, typed error. Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\profile.rs:354: #[test] fn tighten_only_allows_tightening() { let parent = Manifest::from_toml_str(PROFILED_SHELL).expect("parent parses"); - assert!(resolve(&parent, "work").is_ok(), "remembered -> always is a tighten"); + assert!( + resolve(&parent, "work").is_ok(), + "remembered -> always is a tighten" + ); } /// Tighten-only: a profile that *lowers* the approval floor is refused at Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\profile.rs:388: // [unit->REQ-MANIFEST-3] #[test] fn string_dot_path_read_write() { - let mut t: toml::Table = toml::from_str( - "greeting = \"hi\"\n[hook]\nadditionalContext = \"ctx\"\n", - ) - .unwrap(); + let mut t: toml::Table = + toml::from_str("greeting = \"hi\"\n[hook]\nadditionalContext = \"ctx\"\n").unwrap(); // Read: top-level leaf, nested leaf, and a miss. - assert_eq!(string_at(&t, "greeting").and_then(|v| v.as_str()), Some("hi")); assert_eq!( + string_at(&t, "greeting").and_then(|v| v.as_str()), + Some("hi") + ); + assert_eq!( string_at(&t, "hook.additionalContext").and_then(|v| v.as_str()), Some("ctx") ); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\profile.rs:407: // Write: overwrite a leaf, and create an intermediate table. set_string_at(&mut t, "greeting", Value::String("yo".into())).unwrap(); set_string_at(&mut t, "deep.nest.key", Value::String("v".into())).unwrap(); - assert_eq!(string_at(&t, "greeting").and_then(|v| v.as_str()), Some("yo")); - assert_eq!(string_at(&t, "deep.nest.key").and_then(|v| v.as_str()), Some("v")); + assert_eq!( + string_at(&t, "greeting").and_then(|v| v.as_str()), + Some("yo") + ); + assert_eq!( + string_at(&t, "deep.nest.key").and_then(|v| v.as_str()), + Some("v") + ); // Writing through an existing non-table leaf errs (no clobber). assert!(set_string_at(&mut t, "greeting.x", Value::String("z".into())).is_err()); // An empty segment errs. Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\profile.rs:453: ) .expect("parses"); let merged = resolve(&parent, "p").expect("resolves"); - assert_eq!(merged.strings.get("kept").and_then(|v| v.as_str()), Some("base")); - assert_eq!(merged.strings.get("flip").and_then(|v| v.as_str()), Some("profile")); + assert_eq!( + merged.strings.get("kept").and_then(|v| v.as_str()), + Some("base") + ); + assert_eq!( + merged.strings.get("flip").and_then(|v| v.as_str()), + Some("profile") + ); } /// Composite addressing splits on the first `:`; a bare name has no profile. Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\profile.rs:462: #[test] fn split_option_first_colon() { assert_eq!(split_option("claude-spt"), ("claude-spt", None)); - assert_eq!(split_option("claude-spt:work"), ("claude-spt", Some("work"))); + assert_eq!( + split_option("claude-spt:work"), + ("claude-spt", Some("work")) + ); // A profile name may contain '-'; the split is on the first ':' only. assert_eq!( split_option("spt-usbip-driver:hid-only"), Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\registry.rs:98: /// verbs (add + update) BEFORE anything is installed or the registry is written. /// The `Display` is the F-1 operator refusal (names the installed core, the /// floor, and the next action) — the ONE message shape both verbs surface. - CoreFloor { adapter: String, core: String, floor: String }, + CoreFloor { + adapter: String, + core: String, + floor: String, + }, } impl std::fmt::Display for RegistryError { Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\registry.rs:109: RegistryError::NotRegistered(n) => write!(f, "adapter not registered: {n}"), RegistryError::BadRecord(n) => write!(f, "corrupt adapter record: {n}"), RegistryError::InvalidProfileName(n) => { - write!(f, "invalid profile name '{n}' (no ':', path separators, or whitespace)") + write!( + f, + "invalid profile name '{n}' (no ':', path separators, or whitespace)" + ) } RegistryError::ProfileShadowsShipped(n) => { - write!(f, "local profile '{n}' would shadow a shipped profile of the same name") + write!( + f, + "local profile '{n}' would shadow a shipped profile of the same name" + ) } RegistryError::ProfileNotFound(n) => write!(f, "local profile not found: {n}"), RegistryError::ShippedProfileImmutable(n) => { Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\registry.rs:119: - write!(f, "profile '{n}' is shipped (adapter-owned); only local profiles are editable") + write!( + f, + "profile '{n}' is shipped (adapter-owned); only local profiles are editable" + ) } RegistryError::BadStringPointer(m) => { write!(f, "invalid [strings] file pointer: {m}") Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\registry.rs:128: extracted/downloaded. Complete the install (e.g. re-run the installer or \ `spt adapter add`) so the source tree exists, then retry." ), - RegistryError::CoreFloor { adapter, core, floor } => write!( + RegistryError::CoreFloor { + adapter, + core, + floor, + } => write!( f, "adapter '{adapter}' requires spt-core {floor} or newer, but this machine \ runs spt-core {core}. Update spt-core first (`spt update`), then retry." Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\registry.rs:400: // post-copy and survive the source going away (adapter updates overwrite // this — REQ-MANIFEST-5). Pointer mode reads strings/ live from source. if src_strings_dir.is_dir() { - copy_dir_all(&src_strings_dir, &shipped_strings_dir(adapters_dir, &record)) - .map_err(RegistryError::Io)?; + copy_dir_all( + &src_strings_dir, + &shipped_strings_dir(adapters_dir, &record), + ) + .map_err(RegistryError::Io)?; } } save_record(adapters_dir, &record)?; Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\registry.rs:605: profile::resolve_overlay(&parent, &overlay).map_err(RegistryError::Manifest)?; let dir = local_profiles_dir(adapters_dir, adapter); std::fs::create_dir_all(&dir)?; - atomic_write_string(&local_profile_file(adapters_dir, adapter, profile), overlay_toml)?; + atomic_write_string( + &local_profile_file(adapters_dir, adapter, profile), + overlay_toml, + )?; Ok(()) } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\registry.rs:654: // the file's contents (REQ-MANIFEST-5), lazily — so live edits reflect. let Some(rel) = profile::as_file_pointer(value) else { // [impl->REQ-MANIFEST-SUBST] lazy adapter-static substitution at read time. - return Ok(Some(subst_string_value(value.clone(), &record, node.as_deref()))); + return Ok(Some(subst_string_value( + value.clone(), + &record, + node.as_deref(), + ))); }; // Provenance (the update-safety guard): if this key is supplied as a file // pointer by a LOCAL profile, resolve against its user-owned dir (survives Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\registry.rs:688: node, )), Value::Array(arr) => Value::Array( - arr.into_iter().map(|v| subst_string_value(v, record, node)).collect(), + arr.into_iter() + .map(|v| subst_string_value(v, record, node)) + .collect(), ), Value::Table(tbl) => Value::Table( tbl.into_iter() Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\registry.rs:748: let strings = overlay_table .entry("strings".to_string()) .or_insert_with(|| Value::Table(toml::Table::new())); - let strings_table = strings - .as_table_mut() - .ok_or_else(|| RegistryError::BadRecord(format!("profiles/{profile}: [strings] not a table")))?; + let strings_table = strings.as_table_mut().ok_or_else(|| { + RegistryError::BadRecord(format!("profiles/{profile}: [strings] not a table")) + })?; profile::set_string_at(strings_table, key_path, Value::String(value.to_string())) .map_err(RegistryError::Manifest)?; - let overlay_toml = toml::to_string_pretty(&overlay) - .map_err(|e| RegistryError::Manifest(crate::manifest::ManifestError::Validation(e.to_string())))?; + let overlay_toml = toml::to_string_pretty(&overlay).map_err(|e| { + RegistryError::Manifest(crate::manifest::ManifestError::Validation(e.to_string())) + })?; // Re-validate + write atomically through the create-time guards. create_local_profile(adapters_dir, adapter, profile, &overlay_toml) } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\registry.rs:1010: let err = register_with_core(&adapters, &src, 1000, "0.25.0") .expect_err("a below-floor core must be refused"); match err { - RegistryError::CoreFloor { adapter, core, floor } => { + RegistryError::CoreFloor { + adapter, + core, + floor, + } => { assert_eq!(adapter, "highfloor"); assert_eq!(core, "0.25.0"); assert_eq!(floor, "9.9.9"); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\registry.rs:1147: // registered() skips it (not in the active set), never panics/crashes. assert!( - registered(&adapters).iter().all(|(r, _)| r.name != rec.name), + registered(&adapters) + .iter() + .all(|(r, _)| r.name != rec.name), "a deferred-manifest adapter is skipped from the active set, not crashed" ); } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\registry.rs:1178: // Shipped profile. let (_, shipped) = resolve_option(&adapters, "mock-shell:locked").unwrap(); - assert_eq!(approval(&shipped), ShellApproval::Always, "shipped resolves"); + assert_eq!( + approval(&shipped), + ShellApproval::Always, + "shipped resolves" + ); // Local profile (tightens further-or-equal — always over remembered). - create_local_profile(&adapters, "mock-shell", "work", "[shell]\nrequire_approval = \"always\"\n") - .unwrap(); + create_local_profile( + &adapters, + "mock-shell", + "work", + "[shell]\nrequire_approval = \"always\"\n", + ) + .unwrap(); let (_, local) = resolve_option(&adapters, "mock-shell:work").unwrap(); assert_eq!(approval(&local), ShellApproval::Always, "local resolves"); assert_eq!(local_profile_names(&adapters, "mock-shell"), vec!["work"]); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\registry.rs:1197: use crate::manifest::ShellApproval; let tmp = tempfile::tempdir().unwrap(); let adapters = registered_shell(tmp.path()); - create_local_profile(&adapters, "mock-shell", "work", "[shell]\nrequire_approval = \"always\"\n") - .unwrap(); + create_local_profile( + &adapters, + "mock-shell", + "work", + "[shell]\nrequire_approval = \"always\"\n", + ) + .unwrap(); let set = registered(&adapters); let bare = resolve_option_in(&set, &adapters, "mock-shell").unwrap(); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\registry.rs:1205: assert_eq!(approval(&bare), ShellApproval::Remembered, "bare = parent"); let shipped = resolve_option_in(&set, &adapters, "mock-shell:locked").unwrap(); - assert_eq!(approval(&shipped), ShellApproval::Always, "shipped overlays"); + assert_eq!( + approval(&shipped), + ShellApproval::Always, + "shipped overlays" + ); let local = resolve_option_in(&set, &adapters, "mock-shell:work").unwrap(); assert_eq!(approval(&local), ShellApproval::Always, "local overlays"); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\registry.rs:1220: fn local_profile_survives_readd() { let tmp = tempfile::tempdir().unwrap(); let adapters = registered_shell(tmp.path()); - create_local_profile(&adapters, "mock-shell", "work", "[shell]\nrequire_approval = \"always\"\n") - .unwrap(); + create_local_profile( + &adapters, + "mock-shell", + "work", + "[shell]\nrequire_approval = \"always\"\n", + ) + .unwrap(); // Re-register the adapter (adapter update / re-add). let src = seed_source(tmp.path(), "ms-src2", SHELL_COPY_PROFILED); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\registry.rs:1248: // Loosen the consent floor (remembered -> none). assert!(matches!( - create_local_profile(&adapters, "mock-shell", "loose", "[shell]\nrequire_approval = \"none\"\n"), + create_local_profile( + &adapters, + "mock-shell", + "loose", + "[shell]\nrequire_approval = \"none\"\n" + ), Err(RegistryError::Manifest(_)) )); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\registry.rs:1255: // Invalid name (contains the address separator). assert!(matches!( - create_local_profile(&adapters, "mock-shell", "a:b", "[shell]\nrequire_approval = \"always\"\n"), + create_local_profile( + &adapters, + "mock-shell", + "a:b", + "[shell]\nrequire_approval = \"always\"\n" + ), Err(RegistryError::InvalidProfileName(_)) )); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\registry.rs:1270: fn delete_local_profile_rules() { let tmp = tempfile::tempdir().unwrap(); let adapters = registered_shell(tmp.path()); - create_local_profile(&adapters, "mock-shell", "work", "[shell]\nrequire_approval = \"always\"\n") - .unwrap(); + create_local_profile( + &adapters, + "mock-shell", + "work", + "[shell]\nrequire_approval = \"always\"\n", + ) + .unwrap(); assert!(matches!( delete_local_profile(&adapters, "mock-shell", "locked"), Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\registry.rs:1305: // Bare option reads the base string; a missing key is None. assert_eq!( - get_string(&adapters, "mock-shell", "base").unwrap().and_then(|v| v.as_str().map(str::to_string)), + get_string(&adapters, "mock-shell", "base") + .unwrap() + .and_then(|v| v.as_str().map(str::to_string)), Some("parent".to_string()) ); - assert!(get_string(&adapters, "mock-shell", "absent").unwrap().is_none()); + assert!(get_string(&adapters, "mock-shell", "absent") + .unwrap() + .is_none()); // set-string requires a LOCAL profile to exist first. create_local_profile(&adapters, "mock-shell", "work", "").unwrap(); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\registry.rs:1316: set_local_string(&adapters, "mock-shell", "work", "hook.ctx", "deep").unwrap(); // The composite reads the overlaid value; the bare option is unchanged. assert_eq!( - get_string(&adapters, "mock-shell:work", "base").unwrap().and_then(|v| v.as_str().map(str::to_string)), + get_string(&adapters, "mock-shell:work", "base") + .unwrap() + .and_then(|v| v.as_str().map(str::to_string)), Some("overridden".to_string()) ); assert_eq!( Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\registry.rs:1323: - get_string(&adapters, "mock-shell:work", "hook.ctx").unwrap().and_then(|v| v.as_str().map(str::to_string)), + get_string(&adapters, "mock-shell:work", "hook.ctx") + .unwrap() + .and_then(|v| v.as_str().map(str::to_string)), Some("deep".to_string()) ); assert_eq!( Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\registry.rs:1327: - get_string(&adapters, "mock-shell", "base").unwrap().and_then(|v| v.as_str().map(str::to_string)), + get_string(&adapters, "mock-shell", "base") + .unwrap() + .and_then(|v| v.as_str().map(str::to_string)), Some("parent".to_string()), "the bare parent is untouched" ); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\registry.rs:1353: ); let src = seed_source(tmp, "cc-src", &toml_src); let strings_dir = src.join("strings"); - std::fs::create_dir_all(strings_dir.join(Path::new(file_rel).parent().unwrap_or(Path::new("")))) - .unwrap(); + std::fs::create_dir_all( + strings_dir.join(Path::new(file_rel).parent().unwrap_or(Path::new(""))), + ) + .unwrap(); std::fs::write(strings_dir.join(file_rel), body).unwrap(); let adapters = tmp.join("adapters"); register(&adapters, &src, 1000).unwrap(); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\registry.rs:1371: // Pointer → file contents; the inline literal still reads as itself. assert_eq!( - get_string(&adapters, "mock-cc", "body").unwrap().and_then(|v| v.as_str().map(str::to_string)), + get_string(&adapters, "mock-cc", "body") + .unwrap() + .and_then(|v| v.as_str().map(str::to_string)), Some("SKILL BODY".to_string()) ); assert_eq!( Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\registry.rs:1378: - get_string(&adapters, "mock-cc", "inline").unwrap().and_then(|v| v.as_str().map(str::to_string)), + get_string(&adapters, "mock-cc", "inline") + .unwrap() + .and_then(|v| v.as_str().map(str::to_string)), Some("literal".to_string()) ); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\registry.rs:1382: // Lazy: edit the (copied) file; get-string reflects it without re-register. let copied = adapters.join("mock-cc").join("strings").join("skill.md"); - assert!(copied.exists(), "shipped strings/ copied into the held copy"); + assert!( + copied.exists(), + "shipped strings/ copied into the held copy" + ); std::fs::write(&copied, "EDITED BODY").unwrap(); assert_eq!( - get_string(&adapters, "mock-cc", "body").unwrap().and_then(|v| v.as_str().map(str::to_string)), + get_string(&adapters, "mock-cc", "body") + .unwrap() + .and_then(|v| v.as_str().map(str::to_string)), Some("EDITED BODY".to_string()), "lazy read reflects the live file edit" ); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\registry.rs:1410: register(&adapters, &traverse, 1), Err(RegistryError::BadStringPointer(_)) )); - assert!(!adapters.join("esc1").exists(), "escaping pointer records nothing"); + assert!( + !adapters.join("esc1").exists(), + "escaping pointer records nothing" + ); // Absolute path. - let abs_path = if cfg!(windows) { "C:\\\\windows\\\\system32\\\\x" } else { "/etc/passwd" }; + let abs_path = if cfg!(windows) { + "C:\\\\windows\\\\system32\\\\x" + } else { + "/etc/passwd" + }; let absolute = seed_source( tmp.path(), "esc2", Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\registry.rs:1427: register(&adapters, &absolute, 2), Err(RegistryError::BadStringPointer(_)) )); - assert!(!adapters.join("esc2").exists(), "absolute pointer records nothing"); + assert!( + !adapters.join("esc2").exists(), + "absolute pointer records nothing" + ); } // [unit->REQ-MANIFEST-5] a missing-at-READ file (deleted after a valid Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\registry.rs:1456: set_local_string(&adapters, "mock-cc", "work", "body", "LOCAL OVERRIDE").unwrap(); assert_eq!( - get_string(&adapters, "mock-cc:work", "body").unwrap().and_then(|v| v.as_str().map(str::to_string)), + get_string(&adapters, "mock-cc:work", "body") + .unwrap() + .and_then(|v| v.as_str().map(str::to_string)), Some("LOCAL OVERRIDE".to_string()), "local literal leaf-replaces the shipped pointer" ); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\registry.rs:1463: assert_eq!( - get_string(&adapters, "mock-cc", "body").unwrap().and_then(|v| v.as_str().map(str::to_string)), + get_string(&adapters, "mock-cc", "body") + .unwrap() + .and_then(|v| v.as_str().map(str::to_string)), Some("SHIPPED BODY".to_string()), "the bare parent still resolves the shipped file" ); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\registry.rs:1489: "an : fallback target resolves" ); // A local profile target too. - create_local_profile(&adapters, "mock-shell", "work", "[shell]\nrequire_approval = \"always\"\n") - .unwrap(); + create_local_profile( + &adapters, + "mock-shell", + "work", + "[shell]\nrequire_approval = \"always\"\n", + ) + .unwrap(); assert!( resolve_option(&adapters, "mock-shell:work").is_ok(), "an : fallback target resolves" Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\resolve.rs:170: pub fn clear_active(adapters_dir: &Path, target: &str) -> Vec { let mut ap = load(adapters_dir); let key = normalize_basename(target); - let removed: Vec = ap - .0 - .iter() - .filter(|(k, v)| **k == key || crate::profile::split_option(v).0 == target) - .map(|(k, _)| k.clone()) - .collect(); + let removed: Vec = + ap.0.iter() + .filter(|(k, v)| **k == key || crate::profile::split_option(v).0 == target) + .map(|(k, _)| k.clone()) + .collect(); for k in &removed { ap.0.remove(k); } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\resolve.rs:190: /// Returns the removed keys. (A thin alias for [`clear_active`] by adapter name.) pub fn prune_adapter(adapters_dir: &Path, adapter: &str) -> Vec { let mut ap = load(adapters_dir); - let removed: Vec = ap - .0 - .iter() - .filter(|(_, v)| crate::profile::split_option(v).0 == adapter) - .map(|(k, _)| k.clone()) - .collect(); + let removed: Vec = + ap.0.iter() + .filter(|(_, v)| crate::profile::split_option(v).0 == adapter) + .map(|(k, _)| k.clone()) + .collect(); for k in &removed { ap.0.remove(k); } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\resolve.rs:407: "[profiles.live]\n[profiles.live.adapter]\nhostable_types = [\"LiveAgent\"]\n", ); // Without a pointer, the freshest (newer-spt) would win. - assert_eq!(resolve_from_basename(&adapters, "claude").unwrap(), "newer-spt"); + assert_eq!( + resolve_from_basename(&adapters, "claude").unwrap(), + "newer-spt" + ); // Pin claude-spt:live; now it wins for the `claude` binary. let keys = set_active(&adapters, "claude-spt:live").unwrap(); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\resolve.rs:426: let adapters = register_harness(tmp.path(), "claude-spt", &["claude"], 1000, ""); register_harness(tmp.path(), "other-spt", &["claude"], 2000, ""); set_active(&adapters, "claude-spt").unwrap(); - assert_eq!(resolve_from_basename(&adapters, "claude").unwrap(), "claude-spt"); + assert_eq!( + resolve_from_basename(&adapters, "claude").unwrap(), + "claude-spt" + ); // Soft-deregister the pinned adapter; the pointer is now stale. registry::deregister(&adapters, "claude-spt").unwrap(); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\resolve.rs:443: #[test] fn set_clear_prune_rules() { let tmp = tempfile::tempdir().unwrap(); - let adapters = register_harness(tmp.path(), "claude-spt", &["claude", "claude-cli"], 1000, ""); + let adapters = register_harness( + tmp.path(), + "claude-spt", + &["claude", "claude-cli"], + 1000, + "", + ); let keys = set_active(&adapters, "claude-spt").unwrap(); assert_eq!(keys, vec!["claude".to_string(), "claude-cli".to_string()]); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\resolve.rs:461: assert_eq!(load(&adapters).0.len(), 1, "the other binding remains"); // Prune by adapter drops what is left. - assert_eq!(prune_adapter(&adapters, "claude-spt"), vec!["claude-cli".to_string()]); + assert_eq!( + prune_adapter(&adapters, "claude-spt"), + vec!["claude-cli".to_string()] + ); assert!(load(&adapters).0.is_empty()); // An adapter with no host_binaries cannot be set active. Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\resolve.rs:480: let tmp = tempfile::tempdir().unwrap(); let adapters = register_harness(tmp.path(), "claude-spt", &["claude"], 1000, ""); set_active(&adapters, "claude-spt").unwrap(); - assert_eq!(pointer_file(&adapters), adapters.join("active-profiles.toml")); + assert_eq!( + pointer_file(&adapters), + adapters.join("active-profiles.toml") + ); assert!(pointer_file(&adapters).exists()); - assert!(adapters.join("claude-spt").is_dir(), "adapter dir is a sibling"); + assert!( + adapters.join("claude-spt").is_dir(), + "adapter dir is a sibling" + ); } } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\runtime.rs:349: if var.direction != EnvDirection::Read { continue; } - let resolved = captured - .get(name) - .cloned() - .or_else(|| var.value.clone()); + let resolved = captured.get(name).cloned().or_else(|| var.value.clone()); if let Some(value) = resolved { keys.entry(name.clone()) .or_insert_with(|| expand_tilde(&value)); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\runtime.rs:371: let rest = if value == "~" { Some("") } else { - value.strip_prefix("~/").or_else(|| value.strip_prefix("~\\")) + value + .strip_prefix("~/") + .or_else(|| value.strip_prefix("~\\")) }; let Some(rest) = rest else { return value.to_string(); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\runtime.rs:651: /// psyche in the parent's captured account root, not the default. A stamped var /// overrides the ambient value. No-op when the map is empty. // [impl->REQ-PSYCHE-SPAWN-ENV-PARITY] - pub fn with_spawn_env( - mut self, - spawn_env: std::collections::BTreeMap, - ) -> Self { + pub fn with_spawn_env(mut self, spawn_env: std::collections::BTreeMap) -> Self { self.spawn_env = spawn_env; self } Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\runtime.rs:830: label: &str, trace_label: &str, ) -> Result { - let trace_enabled = - matches!(std::env::var("SPT_RCA_PTY_TRACE"), Ok(value) if value == "1"); + let trace_enabled = matches!(std::env::var("SPT_RCA_PTY_TRACE"), Ok(value) if value == "1"); let process_pid = std::process::id(); let child_pid = child.id(); // Drain stdout/stderr on threads to avoid a full-pipe deadlock while we poll. Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\runtime.rs:1173: .command_for(rt.role("echo_commune").unwrap(), &BTreeMap::new()) .unwrap(); assert_eq!( - cmd.get_current_dir().map(|p| p.to_string_lossy().replace('\\', "/")), + cmd.get_current_dir() + .map(|p| p.to_string_lossy().replace('\\', "/")), Some(role_dir_toml), "an adapter-declared role cwd always wins over the caller default" ); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\runtime.rs:1213: // Stamp it → the captured value is threaded onto the spawn. let mut stamps = BTreeMap::new(); - stamps.insert("CLAUDE_CONFIG_DIR".to_string(), "/relocated/root".to_string()); + stamps.insert( + "CLAUDE_CONFIG_DIR".to_string(), + "/relocated/root".to_string(), + ); let rt = ManifestRuntime::new(m).with_spawn_env(stamps); let role = rt.role("psyche_resume").unwrap(); let cmd = rt.command_for(role, &BTreeMap::new()).unwrap(); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\runtime.rs:1233: fn stamp_survives_env_remove() { let m = psyche_manifest("env_remove = [\"CLAUDE_CONFIG_DIR\"]\n"); let mut stamps = BTreeMap::new(); - stamps.insert("CLAUDE_CONFIG_DIR".to_string(), "/relocated/root".to_string()); + stamps.insert( + "CLAUDE_CONFIG_DIR".to_string(), + "/relocated/root".to_string(), + ); let rt = ManifestRuntime::new(m).with_spawn_env(stamps); let role = rt.role("psyche_resume").unwrap(); let cmd = rt.command_for(role, &BTreeMap::new()).unwrap(); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\runtime.rs:1252: fn expand_tilde_expands_leading_home_only() { assert_eq!(expand_tilde("/abs/path"), "/abs/path"); assert_eq!(expand_tilde("plain"), "plain"); - assert_eq!(expand_tilde("a/~/b"), "a/~/b", "a mid-path ~ is not expanded"); + assert_eq!( + expand_tilde("a/~/b"), + "a/~/b", + "a mid-path ~ is not expanded" + ); let home = if cfg!(windows) { std::env::var("USERPROFILE") } else { Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\runtime.rs:1296: let q = keys(&[("psyche_prompt", r#"a "quoted" b"#)]); let argv_q = fill_template_tokens("runner --prompt {psyche_prompt}", &q).unwrap(); assert_eq!(argv_q, vec!["runner", "--prompt", r#"a "quoted" b"#]); - assert_eq!(argv_q.len(), 3, "a value with a quote injects no extra token"); + assert_eq!( + argv_q.len(), + 3, + "a value with a quote injects no extra token" + ); let s = keys(&[("psyche_prompt", "a; rm -rf b")]); let argv_s = fill_template_tokens("runner --prompt {psyche_prompt}", &s).unwrap(); Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\runtime.rs:1303: assert_eq!(argv_s, vec!["runner", "--prompt", "a; rm -rf b"]); - assert_eq!(argv_s.len(), 3, "a value with a semicolon injects no extra token"); + assert_eq!( + argv_s.len(), + 3, + "a value with a semicolon injects no extra token" + ); } // [unit->REQ-MANIFEST-SUBST] the adapter-static substitution primitives Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\runtime.rs:1325: let mut k2 = BTreeMap::new(); inject_adapter_keys(&mut k2, None, Some("only-name")); assert!(!k2.contains_key("adapter_dir")); - assert_eq!(k2.get("adapter_name").map(String::as_str), Some("only-name")); + assert_eq!( + k2.get("adapter_name").map(String::as_str), + Some("only-name") + ); // subst: fills the adapter-static keys + node-static {node}, passes the // session-scoped placeholders through verbatim. Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\runtime.rs:1335: Some("claude-spt"), Some("HOSTX"), ); - assert_eq!(out, "/opt/cc/claude-spt hook {id} {session_id} claude-spt @HOSTX"); + assert_eq!( + out, + "/opt/cc/claude-spt hook {id} {session_id} claude-spt @HOSTX" + ); // an unavailable key (None source) passes through, never errors — {node} too. assert_eq!( subst_adapter_static("{adapter_dir}/x {node}", None, Some("n"), None), Diff in \\?\C:\Users\decid\Documents\projects\spt-core\crates\spt-runtime\src\runtime.rs:1342: "{adapter_dir}/x {node}" ); // an unterminated brace passes through verbatim. - assert_eq!(subst_adapter_static("a{b", Some("d"), Some("n"), None), "a{b"); + assert_eq!( + subst_adapter_static("a{b", Some("d"), Some("n"), None), + "a{b" + ); // command_for resolves {adapter_dir} from the runtime's pinned dir + name. let m = Manifest::from_toml_str( [raw output: artifact://97]