Skip to main content

subc_daemon/config_store/
mod.rs

1//! Durable configuration authority. Callers serialize access under the daemon's
2//! gate lock and run disk/keychain work on a blocking worker. A successful commit
3//! is the only permission to report approval or start delivery; `anchor_pending`
4//! means the bytes committed but their sealed anchor has not caught up yet.
5//! While unstamped, retained bytes are history, not authority. In digest-only
6//! mode the committed in-memory stamp rules during the run: editing the file's
7//! stamped bit cannot re-enable the gate. A restart reads the file as found: a
8//! present file that does not parse as a store opens in recovery on every
9//! platform, never as "never stamped". Deleting the file, or rewriting it into
10//! another well-formed store, while the daemon is stopped, and replaying an
11//! older store file, remain the documented digest-only limitation.
12
13mod disk;
14mod writer_lock;
15pub use writer_lock::{StoreWriterLock, WriterLockError};
16mod records;
17#[cfg(feature = "test-support")]
18pub mod testing;
19#[cfg(test)]
20mod tests;
21
22pub use records::*;
23
24use hmac::{Hmac, Mac};
25use serde::{Deserialize, Serialize};
26use sha2::{Digest as _, Sha256};
27use std::{
28    io,
29    path::{Path, PathBuf},
30};
31use subc_os::config_keychain::{
32    AnchorState, KeychainError, KeychainState, KeychainStore, StoreAnchor, StoreKey,
33};
34
35pub const STORE_FORMAT_VERSION: u32 = 1;
36pub const STORE_FILE: &str = "approved.json";
37/// Bound both reads and publications so a successful commit remains readable.
38pub const STORE_BYTE_LIMIT: usize = 64 * 1024 * 1024;
39const KEYCHAIN_SERVICE: &str = "com.cortexkit.subc.config-gate";
40
41fn wall_time_ms() -> u64 {
42    std::time::SystemTime::now()
43        .duration_since(std::time::UNIX_EPOCH)
44        .map_or(0, |duration| {
45            u64::try_from(duration.as_millis()).unwrap_or(u64::MAX)
46        })
47}
48
49#[derive(Clone, Copy, Debug, PartialEq, Eq)]
50pub enum StoreState {
51    Unstamped,
52    Stamped,
53    StoreUnverified,
54    StoreMissing,
55}
56
57#[derive(Clone, Copy, Debug, PartialEq, Eq)]
58pub enum StoreErrorCode {
59    StoreUnverified,
60    StoreMissing,
61    StoreTampered,
62    StoreTooLarge,
63    AnchorPending,
64    GenerationPruned,
65    GenerationMissing,
66    RevisionExhausted,
67    InvalidState,
68    Io,
69}
70
71#[derive(Debug)]
72pub struct StoreError {
73    pub code: StoreErrorCode,
74    pub detail: String,
75}
76impl StoreError {
77    fn new(code: StoreErrorCode, detail: impl ToString) -> Self {
78        Self {
79            code,
80            detail: detail.to_string(),
81        }
82    }
83    fn serialization(error: impl ToString) -> Self {
84        Self::new(StoreErrorCode::InvalidState, error)
85    }
86}
87impl std::fmt::Display for StoreError {
88    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
89        write!(f, "{:?}: {}", self.code, self.detail)
90    }
91}
92impl std::error::Error for StoreError {}
93impl From<io::Error> for StoreError {
94    fn from(error: io::Error) -> Self {
95        Self::new(StoreErrorCode::Io, error)
96    }
97}
98
99/// Emitted by the store, drained by the caller into the daemon activity log.
100#[derive(Clone, Debug, PartialEq, Eq)]
101pub struct StoreActivity {
102    pub event: &'static str,
103    pub detail: String,
104}
105
106/// Shared stand-in anchor for daemon-owner unit tests, never a host keychain.
107#[cfg(test)]
108#[derive(Clone, Default)]
109pub(crate) struct TestStoreKey(std::sync::Arc<std::sync::Mutex<tests::MemoryKey>>);
110
111#[cfg(test)]
112impl TestStoreKey {
113    pub(crate) fn fail_anchor(&self, fail: bool) {
114        self.0.lock().unwrap().set_anchor_failure(fail);
115    }
116
117    pub(crate) fn anchor_calls(&self) -> usize {
118        self.0.lock().unwrap().anchor_calls()
119    }
120}
121
122#[derive(Clone, Debug)]
123pub struct StoreStatus {
124    pub state: StoreState,
125    pub integrity: IntegrityMode,
126    pub revision: u64,
127    pub base_revision: u64,
128    pub anchor_pending: bool,
129    pub warnings: Vec<String>,
130}
131
132/// An absolute path persisted by installation in the service definition. It is
133/// never re-resolved from environment variables at store open time.
134pub struct StoreRoot(PathBuf);
135impl StoreRoot {
136    pub fn from_service_definition(path: PathBuf) -> io::Result<Self> {
137        if !path.is_absolute() {
138            return Err(io::Error::new(
139                io::ErrorKind::InvalidInput,
140                "store root must be absolute",
141            ));
142        }
143        Ok(Self(path))
144    }
145    /// Installation default only. Windows uses the token/registry profile, not
146    /// APPDATA, LOCALAPPDATA, USERPROFILE or XDG values from a process.
147    pub fn installation_default() -> io::Result<Self> {
148        #[cfg(windows)]
149        let path = subc_os::profile_dir()?
150            .join("AppData")
151            .join("Local")
152            .join("cortexkit")
153            .join("config");
154        #[cfg(not(windows))]
155        let path = subc_os::real_user_home_dir()?
156            .join(".local")
157            .join("share")
158            .join("cortexkit")
159            .join("config");
160        Self::from_service_definition(path)
161    }
162    pub fn path(&self) -> &Path {
163        &self.0
164    }
165}
166
167#[derive(Clone, Serialize, Deserialize)]
168struct Envelope {
169    format_version: u32,
170    revision: u64,
171    previous_digest: Option<[u8; 32]>,
172    integrity: IntegrityMode,
173    body: StoreBody,
174    #[serde(skip_serializing_if = "Option::is_none")]
175    mac: Option<[u8; 32]>,
176}
177impl Envelope {
178    fn authenticate(&self, key: &StoreKey) -> Result<[u8; 32], StoreError> {
179        // Hash the complete envelope without its MAC. This binds the mode and
180        // format as well as the body in the crash window before anchoring.
181        let mut unsigned = self.clone();
182        unsigned.mac = None;
183        let body = serde_json::to_vec(&unsigned).map_err(StoreError::serialization)?;
184        Ok(self.mac_over_bytes(key, &body))
185    }
186    fn mac_over_bytes(&self, key: &StoreKey, body: &[u8]) -> [u8; 32] {
187        let mut mac =
188            Hmac::<Sha256>::new_from_slice(key.as_bytes()).expect("HMAC accepts 32 bytes");
189        mac.update(b"subc-config-store-v1\0");
190        mac.update(&self.revision.to_be_bytes());
191        mac.update(&[u8::from(self.previous_digest.is_some())]);
192        mac.update(&self.previous_digest.unwrap_or([0; 32]));
193        mac.update(&Sha256::digest(body));
194        mac.finalize().into_bytes().into()
195    }
196    fn valid_mac(&self, key: &StoreKey, bytes: &[u8]) -> bool {
197        use subtle::ConstantTimeEq;
198        let Some(saved) = self.mac else {
199            return false;
200        };
201        // The format writes the MAC as the final field. Authenticate the exact
202        // preceding bytes, not a deserialized/reserialized body: unknown fields
203        // and changed whitespace must not disappear during crash recovery.
204        let mut suffix = b",\"mac\":".to_vec();
205        suffix.extend(serde_json::to_vec(&saved).expect("fixed byte array serializes"));
206        suffix.push(b'}');
207        let Some(prefix) = bytes.strip_suffix(suffix.as_slice()) else {
208            return false;
209        };
210        let mut unsigned = prefix.to_vec();
211        unsigned.push(b'}');
212        bool::from(saved.ct_eq(&self.mac_over_bytes(key, &unsigned)))
213    }
214}
215
216enum Backend {
217    Unsupported,
218    Os(KeychainStore),
219    Unavailable(String),
220    #[cfg(feature = "test-support")]
221    File(subc_os::config_keychain::testing::FileKeyStore),
222    #[cfg(test)]
223    Memory(std::sync::Arc<std::sync::Mutex<tests::MemoryKey>>),
224}
225impl Backend {
226    fn production() -> Self {
227        match KeychainStore::open(KEYCHAIN_SERVICE) {
228            Ok(store) => Self::Os(store),
229            Err(KeychainError::Unsupported) => Self::Unsupported,
230            Err(error) => Self::Unavailable(error.to_string()),
231        }
232    }
233    fn load(&self) -> Result<Option<KeychainState>, StoreError> {
234        let result = match self {
235            Self::Unsupported => return Ok(None),
236            Self::Unavailable(error) => {
237                return Err(StoreError::new(StoreErrorCode::StoreUnverified, error))
238            }
239            Self::Os(store) => store.load(),
240            #[cfg(feature = "test-support")]
241            Self::File(store) => store.load(),
242            #[cfg(test)]
243            Self::Memory(store) => return store.lock().unwrap().load(),
244        };
245        result.map_err(|e| StoreError::new(StoreErrorCode::StoreUnverified, e))
246    }
247    fn create(&self) -> Result<(), StoreError> {
248        let mut bytes = [0; 32];
249        getrandom::getrandom(&mut bytes).map_err(StoreError::serialization)?;
250        let result = match self {
251            Self::Os(store) => store.create(StoreKey::new(bytes)),
252            #[cfg(feature = "test-support")]
253            Self::File(store) => store.create(StoreKey::new(bytes)),
254            #[cfg(test)]
255            Self::Memory(store) => {
256                store.lock().unwrap().key = Some(bytes);
257                return Ok(());
258            }
259            _ => {
260                return Err(StoreError::new(
261                    StoreErrorCode::StoreUnverified,
262                    "sealing unavailable",
263                ))
264            }
265        };
266        result.map_err(|e| StoreError::new(StoreErrorCode::StoreUnverified, e))
267    }
268    fn seal_available(&self) -> bool {
269        !matches!(self, Self::Unsupported)
270    }
271    fn anchor(&self, pair: StoreAnchor, stamped: bool) -> Result<(), StoreError> {
272        let result = match self {
273            Self::Os(store) => {
274                if stamped {
275                    store.update_anchor(pair)
276                } else {
277                    store.clear_anchor(pair.revision)
278                }
279            }
280            #[cfg(feature = "test-support")]
281            Self::File(store) => {
282                if stamped {
283                    store.update_anchor(pair)
284                } else {
285                    store.clear_anchor(pair.revision)
286                }
287            }
288            #[cfg(test)]
289            Self::Memory(store) => return store.lock().unwrap().anchor(pair, stamped),
290            _ => {
291                return Err(StoreError::new(
292                    StoreErrorCode::StoreUnverified,
293                    "key access unavailable; restore key access",
294                ))
295            }
296        };
297        result.map_err(|e| StoreError::new(StoreErrorCode::AnchorPending, e))
298    }
299}
300
301struct UnanchoredAck {
302    visible: StoreBody,
303    tuple: Tuple,
304    generation: u64,
305}
306
307#[cfg(test)]
308pub(crate) type IoThreads =
309    std::sync::Arc<std::sync::Mutex<Vec<(&'static str, std::thread::ThreadId)>>>;
310
311/// One instance per daemon, serialized by its gate lock. No method reads live
312/// configuration files. Diagnostic snapshots are validated and redacted; approved
313/// delivery bytes may contain vault reference names, never literal secret values.
314pub struct ConfigStore {
315    root: StoreRoot,
316    backend: Backend,
317    envelope: Envelope,
318    state: StoreState,
319    publication_sequence: u64,
320    expected_digest: Option<[u8; 32]>,
321    pending_anchor: Option<(StoreAnchor, bool)>,
322    pending_prior_anchor: Option<AnchorState>,
323    warnings: Vec<String>,
324    activities: Vec<StoreActivity>,
325    deferred_failure: Option<StoreBody>,
326    // The approved-store file containing the ACK has been atomically renamed,
327    // but that ACK is not activation authority until the keychain anchor commits.
328    // Readers and a competing NACK use the previous pending/active vector.
329    unanchored_ack: Option<UnanchoredAck>,
330    /// The generation this daemon booted its approved configuration from.
331    booted_generation: Option<u64>,
332    #[cfg(test)]
333    byte_limit: usize,
334    #[cfg(test)]
335    io_threads: Option<IoThreads>,
336    #[cfg(feature = "test-support")]
337    hooks: Option<testing::TestSupport>,
338}
339impl ConfigStore {
340    /// A process-local witness of atomic publication. Recovery can repeat the
341    /// persisted revision and generation, but never resets this sequence.
342    pub(crate) fn publication_sequence(&self) -> u64 {
343        self.publication_sequence
344    }
345
346    #[cfg(all(test, unix))]
347    pub(crate) fn clear_delivery_snapshot_for_test(&mut self, generation: u64) {
348        let mut body = self.envelope.body.clone();
349        body.generations.get_mut(&generation).unwrap().delivery = None;
350        self.publish(body, false, wall_time_ms()).unwrap();
351    }
352    /// A verified loaded view for gate-locked admission. The owner performs
353    /// `check` outside the module gate before preparing the launch witness.
354    pub(crate) fn loaded_admission_state(&self) -> (StoreState, &StoreBody) {
355        (
356            self.state,
357            self.deferred_failure
358                .as_ref()
359                .or(self.unanchored_ack.as_ref().map(|ack| &ack.visible))
360                .unwrap_or(&self.envelope.body),
361        )
362    }
363
364    /// The cache publisher has already verified authority under its owner lock.
365    /// Observe the anchor barrier without repeating disk or keychain checks.
366    pub(crate) fn loaded_anchor_pending(&self) -> bool {
367        self.pending_anchor.is_some()
368    }
369    #[cfg(test)]
370    pub(crate) fn observe_io_threads(&mut self, threads: IoThreads) {
371        self.io_threads = Some(threads);
372    }
373
374    #[cfg(test)]
375    fn observe_io_thread(&self, operation: &'static str) {
376        if let Some(threads) = &self.io_threads {
377            threads
378                .lock()
379                .unwrap()
380                .push((operation, std::thread::current().id()));
381        }
382    }
383
384    /// Unit tests never consult a host keychain, even on a signed test runner.
385    #[cfg(test)]
386    pub(crate) fn open_digest_only_for_tests(root: StoreRoot) -> Self {
387        Self::load(root, Backend::Unsupported)
388    }
389    #[cfg(test)]
390    pub(crate) fn open_sealed_for_tests(root: StoreRoot, key: TestStoreKey) -> Self {
391        Self::load(root, Backend::Memory(key.0))
392    }
393    /// Reads only; the first stamp creates the directory and file. Caller must
394    /// hold its daemon single-writer/start lock until this instance is dropped.
395    pub fn open(root: StoreRoot) -> Self {
396        Self::load(root, Backend::production())
397    }
398
399    fn load(root: StoreRoot, backend: Backend) -> Self {
400        let mut store = Self {
401            root,
402            backend,
403            envelope: Envelope {
404                format_version: STORE_FORMAT_VERSION,
405                revision: 0,
406                previous_digest: None,
407                integrity: IntegrityMode::DigestOnly,
408                body: StoreBody::default(),
409                mac: None,
410            },
411            state: StoreState::Unstamped,
412            publication_sequence: 0,
413            expected_digest: None,
414            pending_anchor: None,
415            pending_prior_anchor: None,
416            warnings: Vec::new(),
417            activities: Vec::new(),
418            deferred_failure: None,
419            unanchored_ack: None,
420            booted_generation: None,
421            #[cfg(test)]
422            byte_limit: STORE_BYTE_LIMIT,
423            #[cfg(test)]
424            io_threads: None,
425            #[cfg(feature = "test-support")]
426            hooks: None,
427        };
428        if let Err(error) = store.start_check() {
429            store.state = if error.code == StoreErrorCode::StoreMissing {
430                StoreState::StoreMissing
431            } else {
432                StoreState::StoreUnverified
433            };
434            store.tamper_activity(&error.to_string());
435            store.warnings.push(error.to_string());
436        }
437        store
438    }
439
440    fn start_check(&mut self) -> Result<(), StoreError> {
441        let key = self.backend.load()?;
442        let bytes = disk::read(&self.path())
443            .map_err(|e| StoreError::new(StoreErrorCode::StoreUnverified, e))?;
444        self.expected_digest = bytes.as_deref().map(hash);
445        // A cleared sealed anchor makes all file states non-authoritative. In
446        // particular an old stamped store cannot re-enable the gate after unstamp.
447        if key
448            .as_ref()
449            .is_some_and(|k| k.anchor.current.is_none() && k.anchor.high_water > 0)
450        {
451            if let Some(bytes) = &bytes {
452                if let Ok(envelope) = serde_json::from_slice::<Envelope>(bytes) {
453                    if envelope.format_version == STORE_FORMAT_VERSION
454                        && !envelope.body.stamped
455                        && envelope.revision == key.as_ref().unwrap().anchor.high_water
456                        && envelope.valid_mac(&key.as_ref().unwrap().key, bytes)
457                    {
458                        self.envelope = envelope;
459                    }
460                }
461            }
462            self.warnings
463                .push("Sealed anchor is cleared; files are authoritative".into());
464            if self.envelope.revision == 0 {
465                self.warnings.push(
466                    "Lost or replayed store: generation-id continuity is not guaranteed".into(),
467                );
468            }
469            self.envelope.integrity = IntegrityMode::Sealed;
470            self.envelope.revision = key.as_ref().unwrap().anchor.high_water;
471            return Ok(());
472        }
473        let Some(bytes) = bytes else {
474            if key.as_ref().is_some_and(|k| k.anchor.current.is_some()) {
475                return Err(StoreError::new(
476                    StoreErrorCode::StoreMissing,
477                    "anchored store is missing",
478                ));
479            }
480            return Ok(());
481        };
482        let value = serde_json::from_slice::<serde_json::Value>(&bytes);
483        if value
484            .as_ref()
485            .ok()
486            .and_then(|v| v.get("format_version"))
487            .and_then(|v| v.as_u64())
488            .is_some_and(|v| v != u64::from(STORE_FORMAT_VERSION))
489        {
490            return Err(StoreError::new(
491                StoreErrorCode::StoreUnverified,
492                "unsupported store format",
493            ));
494        }
495        // Every writer publishes revision 1 or later. A present file that is
496        // not a well-formed store is corruption, never evidence of an install
497        // that was never stamped, with or without a sealed anchor.
498        let envelope = match serde_json::from_slice::<Envelope>(&bytes) {
499            Ok(envelope) if envelope.revision > 0 => envelope,
500            _ => {
501                return Err(StoreError::new(
502                    StoreErrorCode::StoreUnverified,
503                    "approved store is present but unparseable",
504                ))
505            }
506        };
507        if let Some(key) = key {
508            if let Some(anchor) = key.anchor.current {
509                let exact = self.expected_digest == Some(anchor.sha256)
510                    && envelope.revision == anchor.revision;
511                let next = anchor.revision.checked_add(1) == Some(envelope.revision)
512                    && envelope.previous_digest == Some(anchor.sha256)
513                    && envelope.valid_mac(&key.key, &bytes);
514                if envelope.integrity != IntegrityMode::Sealed || !(exact || next) {
515                    return Err(StoreError::new(
516                        StoreErrorCode::StoreUnverified,
517                        "sealed store does not match anchor",
518                    ));
519                }
520                self.envelope = envelope;
521                if next {
522                    self.pending_prior_anchor = Some(key.anchor);
523                    self.pending_anchor = Some((
524                        StoreAnchor {
525                            revision: self.envelope.revision,
526                            sha256: hash(&bytes),
527                        },
528                        self.envelope.body.stamped,
529                    ));
530                    if let Err(error) = self.retry_anchor() {
531                        self.warnings.push(error.to_string());
532                    }
533                }
534                self.state = if self.envelope.body.stamped || self.pending_anchor.is_some() {
535                    StoreState::Stamped
536                } else {
537                    StoreState::Unstamped
538                };
539                return Ok(());
540            }
541        }
542        if envelope.integrity == IntegrityMode::Sealed {
543            return Err(StoreError::new(
544                StoreErrorCode::StoreUnverified,
545                "sealed key missing or unavailable; restore key access",
546            ));
547        }
548        self.state = if envelope.body.stamped {
549            StoreState::Stamped
550        } else {
551            StoreState::Unstamped
552        };
553        self.envelope = envelope;
554        if self.backend.seal_available() {
555            self.warnings
556                .push("Re-stamp would seal this digest-only store".into());
557        }
558        Ok(())
559    }
560
561    fn path(&self) -> PathBuf {
562        self.root.0.join(STORE_FILE)
563    }
564    fn tamper_activity(&mut self, detail: &str) {
565        self.activities.push(StoreActivity {
566            event: "config.tamper",
567            detail: detail.into(),
568        });
569    }
570    fn usable(&self) -> Result<(), StoreError> {
571        match self.state {
572            StoreState::StoreMissing => Err(StoreError::new(
573                StoreErrorCode::StoreMissing,
574                "recovery required",
575            )),
576            StoreState::StoreUnverified => Err(StoreError::new(
577                StoreErrorCode::StoreUnverified,
578                "recovery required",
579            )),
580            _ => Ok(()),
581        }
582    }
583    /// Re-check before every authority use, including after delivery writes.
584    pub fn check(&mut self) -> Result<(), StoreError> {
585        self.usable()?;
586        if self.envelope.integrity == IntegrityMode::Sealed {
587            #[cfg(test)]
588            self.observe_io_thread("keychain_load");
589            let valid = self.backend.load().ok().flatten().is_some_and(|key| {
590                let current = StoreAnchor {
591                    revision: self.envelope.revision,
592                    sha256: self.expected_digest.unwrap_or([0; 32]),
593                };
594                let covered = if self.envelope.body.stamped {
595                    key.anchor.current == Some(current)
596                } else {
597                    key.anchor.current.is_none() && key.anchor.high_water == current.revision
598                };
599                // Until publication is anchored, only the exact prior anchor
600                // or the new committed pair is acceptable. Recovery may replace
601                // rejected bytes whose digest does not match that prior anchor.
602                let waiting =
603                    self.pending_anchor.is_some() && self.pending_prior_anchor == Some(key.anchor);
604                covered || waiting
605            });
606            if !valid {
607                self.state = StoreState::StoreUnverified;
608                self.tamper_activity(
609                    "Sealed anchor changed or key access was lost while daemon was running",
610                );
611                return Err(StoreError::new(
612                    StoreErrorCode::StoreUnverified,
613                    "restore sealed key/anchor access",
614                ));
615            }
616        }
617        if self.state == StoreState::Unstamped && self.pending_anchor.is_none() {
618            return Ok(());
619        }
620        #[cfg(test)]
621        self.observe_io_thread("store_hash");
622        let actual = disk::read(&self.path()).map(|bytes| bytes.as_deref().map(hash));
623        if !matches!(actual, Ok(digest) if digest == self.expected_digest) {
624            self.state = StoreState::StoreUnverified;
625            self.tamper_activity("Approved store changed while daemon was running");
626            return Err(StoreError::new(
627                StoreErrorCode::StoreTampered,
628                "approved store changed",
629            ));
630        }
631        Ok(())
632    }
633    pub fn body(&mut self) -> Result<&StoreBody, StoreError> {
634        self.check()?;
635        Ok(self
636            .deferred_failure
637            .as_ref()
638            .or(self.unanchored_ack.as_ref().map(|ack| &ack.visible))
639            .unwrap_or(&self.envelope.body))
640    }
641    pub fn status(&mut self) -> StoreStatus {
642        let _ = self.check();
643        self.loaded_status()
644    }
645
646    /// State as of the last integrity check. This is not a fresh integrity read:
647    /// it performs no disk or keychain work.
648    pub(crate) fn loaded_status(&self) -> StoreStatus {
649        StoreStatus {
650            state: self.state,
651            integrity: self.envelope.integrity,
652            revision: self.envelope.revision,
653            base_revision: self.envelope.body.base_revision,
654            anchor_pending: self.pending_anchor.is_some(),
655            warnings: {
656                let mut warnings = self.warnings.clone();
657                if self.envelope.integrity == IntegrityMode::DigestOnly {
658                    warnings.push("Digest-only: while the daemon is stopped, rewriting the store into another well-formed store, replay, deletion and data-home relocation are not detected".into());
659                }
660                warnings.push("Deleting the sealed key and rewriting the store as digest-only bypasses sealing; pre-gate binaries ignore the store".into());
661                warnings
662            },
663        }
664    }
665    pub fn take_activities(&mut self) -> Vec<StoreActivity> {
666        std::mem::take(&mut self.activities)
667    }
668    pub(crate) fn record_program_refusal(
669        &mut self,
670        module: &str,
671        approved_base: subc_config::Digest,
672        refused_identity: subc_config::Digest,
673        held_modules: &std::collections::BTreeSet<String>,
674    ) -> Result<(), StoreError> {
675        self.delivery_ready()?;
676        if self.state != StoreState::Stamped {
677            return Ok(());
678        }
679        let refusal = ProgramRefusal {
680            module: module.into(),
681            approved_base,
682            refused_identity,
683        };
684        if self.envelope.body.program_refusals.contains(&refusal) {
685            return Ok(());
686        }
687        let mut body = self.envelope.body.clone();
688        body.program_refusals.push(refusal);
689        while body.program_refusals.len() > PROGRAM_REFUSAL_LIMIT {
690            if let Some(index) = body
691                .program_refusals
692                .iter()
693                .position(|record| !held_modules.contains(&record.module))
694            {
695                body.program_refusals.remove(index);
696            } else {
697                tracing::warn!(
698                    retained = body.program_refusals.len(),
699                    limit = PROGRAM_REFUSAL_LIMIT,
700                    "program refusal limit exceeded: every remaining record protects a held module"
701                );
702                break;
703            }
704        }
705        let result = self.publish(body, false, wall_time_ms());
706        if result.is_ok()
707            || result
708                .as_ref()
709                .is_err_and(|error| error.code == StoreErrorCode::AnchorPending)
710        {
711            self.activities.push(StoreActivity {
712                event: "config.refused",
713                detail: format!("{module}: program_refused; covered identity is not approved"),
714            });
715        }
716        result
717    }
718    /// No approval/delivery may rely on a pending revision before this succeeds.
719    pub fn delivery_ready(&mut self) -> Result<(), StoreError> {
720        self.check()?;
721        if self.pending_anchor.is_some() {
722            return Err(StoreError::new(
723                StoreErrorCode::AnchorPending,
724                "anchor update pending",
725            ));
726        }
727        Ok(())
728    }
729    pub fn retry_anchor(&mut self) -> Result<(), StoreError> {
730        self.check()?;
731        if let Some((pair, stamped)) = self.pending_anchor {
732            self.backend.anchor(pair, stamped)?;
733            self.pending_anchor = None;
734            self.pending_prior_anchor = None;
735            if let Some(ack) = self.unanchored_ack.take() {
736                // A different module may fail while this ACK is unanchored.
737                // Preserve that failure without discarding the now-anchored ACK.
738                if let Some(failure) = self.deferred_failure.as_mut() {
739                    let still_pending = failure.versions.iter().any(|(tuple, versions)| {
740                        tuple == &ack.tuple && versions.pending == Some(ack.generation)
741                    });
742                    let failed_module =
743                        failure
744                            .generations
745                            .get(&ack.generation)
746                            .is_some_and(|entry| {
747                                entry.generation.never_redeliver.contains(&ack.tuple.module)
748                            });
749                    if still_pending && !failed_module {
750                        if let Some((_, approved)) = self
751                            .envelope
752                            .body
753                            .versions
754                            .iter()
755                            .find(|(tuple, _)| tuple == &ack.tuple)
756                        {
757                            if let Some((_, visible)) = failure
758                                .versions
759                                .iter_mut()
760                                .find(|(tuple, _)| tuple == &ack.tuple)
761                            {
762                                *visible = approved.clone();
763                            }
764                        }
765                        if let Some(entry) = failure.generations.get_mut(&ack.generation) {
766                            entry
767                                .generation
768                                .module_states
769                                .insert(ack.tuple.module, subc_config::GenerationState::Active);
770                            if !entry
771                                .generation
772                                .module_states
773                                .values()
774                                .any(|state| *state == subc_config::GenerationState::Failed)
775                            {
776                                entry.outcome = "active".into();
777                            }
778                        }
779                    }
780                }
781            }
782            self.state = if stamped {
783                StoreState::Stamped
784            } else {
785                StoreState::Unstamped
786            };
787        }
788        if let Some(body) = self.deferred_failure.take() {
789            if let Err(error) = self.publish(body.clone(), false, wall_time_ms()) {
790                self.deferred_failure = Some(body);
791                return Err(error);
792            }
793        }
794        Ok(())
795    }
796}
797
798fn hash(bytes: &[u8]) -> [u8; 32] {
799    Sha256::digest(bytes).into()
800}
801
802impl ConfigStore {
803    fn next_revision(&self, sealed: bool, fresh: bool) -> Result<u64, StoreError> {
804        let previous = if sealed {
805            self.backend
806                .load()?
807                .ok_or_else(|| {
808                    StoreError::new(StoreErrorCode::StoreUnverified, "sealing key missing")
809                })?
810                .anchor
811                .high_water
812        } else if fresh {
813            // A rejected sealed counter is never trusted. Digest-only expressly
814            // has no replay protection, including when recovering a parsed file.
815            disk::read(&self.path())
816                .ok()
817                .flatten()
818                .and_then(|b| serde_json::from_slice::<Envelope>(&b).ok())
819                .map_or(0, |e| {
820                    if e.revision == u64::MAX {
821                        0
822                    } else {
823                        e.revision
824                    }
825                })
826        } else {
827            self.envelope.revision
828        };
829        previous.checked_add(1).ok_or_else(|| {
830            StoreError::new(
831                StoreErrorCode::RevisionExhausted,
832                "store revision exhausted",
833            )
834        })
835    }
836
837    fn publish(&mut self, body: StoreBody, fresh: bool, now_ms: u64) -> Result<(), StoreError> {
838        if self.pending_anchor.is_some() {
839            return Err(StoreError::new(
840                StoreErrorCode::AnchorPending,
841                "anchor update pending",
842            ));
843        }
844        if !fresh {
845            self.check()?;
846        } else {
847            self.expected_digest = disk::read(&self.path())
848                .map_err(|e| StoreError::new(StoreErrorCode::StoreUnverified, e))?
849                .as_deref()
850                .map(hash);
851        }
852        let sealed = self.envelope.integrity == IntegrityMode::Sealed;
853        let revision = self.next_revision(sealed, fresh)?;
854        let mut envelope = Envelope {
855            format_version: STORE_FORMAT_VERSION,
856            revision,
857            previous_digest: self.expected_digest,
858            integrity: self.envelope.integrity,
859            body,
860            mac: None,
861        };
862        let mut prior_anchor = None;
863        let key = if sealed {
864            let key = self
865                .backend
866                .load()?
867                .ok_or_else(|| StoreError::new(StoreErrorCode::StoreUnverified, "key missing"))?;
868            prior_anchor = Some(key.anchor);
869            Some(key)
870        } else {
871            None
872        };
873        #[cfg(test)]
874        let limit = self.byte_limit;
875        #[cfg(not(test))]
876        let limit = STORE_BYTE_LIMIT;
877        let bytes = loop {
878            envelope.mac = key
879                .as_ref()
880                .map(|key| envelope.authenticate(&key.key))
881                .transpose()?;
882            let bytes = serde_json::to_vec(&envelope).map_err(StoreError::serialization)?;
883            if bytes.len() <= limit {
884                break bytes;
885            }
886            if !envelope.body.prune_oldest(now_ms) {
887                return Err(StoreError::new(StoreErrorCode::StoreTooLarge,
888                    format!("candidate exceeds STORE_BYTE_LIMIT ({limit} bytes); active, recovery and pending versions cannot be pruned")));
889            }
890        };
891        let next_publication = self.publication_sequence.checked_add(1).ok_or_else(|| {
892            StoreError::new(
893                StoreErrorCode::RevisionExhausted,
894                "publication sequence exhausted",
895            )
896        })?;
897        let path = self.path();
898        let publication_sequence = &mut self.publication_sequence;
899        if let Err(error) = disk::publish(&path, &bytes, |point| {
900            // Atomic replacement is the publication boundary, even when a
901            // later hook or keychain-anchor update reports an error.
902            if point == disk::PausePoint::AfterRename {
903                *publication_sequence = next_publication;
904            }
905            #[cfg(feature = "test-support")]
906            if let Some(hooks) = &self.hooks {
907                hooks.pause(point)?;
908            }
909            let _ = point;
910            Ok(())
911        }) {
912            // A failure after rename may already have exposed new bytes. Do not
913            // report success or pretend the old in-memory authority is durable.
914            self.state = StoreState::StoreUnverified;
915            return Err(error.into());
916        }
917        self.expected_digest = Some(hash(&bytes));
918        self.state = if sealed || envelope.body.stamped {
919            StoreState::Stamped
920        } else {
921            StoreState::Unstamped
922        };
923        self.envelope = envelope;
924        if sealed {
925            self.pending_prior_anchor = prior_anchor;
926            self.pending_anchor = Some((
927                StoreAnchor {
928                    revision,
929                    sha256: hash(&bytes),
930                },
931                self.envelope.body.stamped,
932            ));
933            #[cfg(feature = "test-support")]
934            if let Some(hooks) = &self.hooks {
935                hooks.pause(disk::PausePoint::BeforeAnchor)?;
936            }
937            self.retry_anchor()?;
938        }
939        Ok(())
940    }
941
942    /// Receives a fully approved generation. `observed` must be a fresh snapshot
943    /// of all files, not only the plan's read set, so unrelated edits survive
944    /// proposal rebasing. The caller has checked plan freshness and approval.
945    pub fn commit_generation(
946        &mut self,
947        mut entry: HistoryEntry,
948        approved: Snapshot,
949        observed: Snapshot,
950        now_ms: u64,
951    ) -> Result<u64, StoreError> {
952        self.delivery_ready()?;
953        let kind = entry.kind;
954        if entry.generation.approval_channel == subc_config::ApprovalChannel::DevelopmentPlacement
955            && kind != CommitKind::Development
956        {
957            return Err(StoreError::new(
958                StoreErrorCode::InvalidState,
959                "development placement is not an approval channel for this commit",
960            ));
961        }
962        if self.state == StoreState::Unstamped && kind != CommitKind::Stamp {
963            return Err(StoreError::new(
964                StoreErrorCode::InvalidState,
965                "first commit must be a stamp",
966            ));
967        }
968        if kind == CommitKind::Stamp {
969            self.select_stamp_mode()?;
970        }
971        let id = self
972            .envelope
973            .body
974            .last_generation
975            .checked_add(1)
976            .ok_or_else(|| {
977                StoreError::new(
978                    StoreErrorCode::RevisionExhausted,
979                    "generation ids exhausted",
980                )
981            })?;
982        entry.generation.id = id;
983        let mut body = self.envelope.body.clone();
984        body.last_generation = id;
985        body.base_revision = self.next_revision(
986            self.envelope.integrity == IntegrityMode::Sealed,
987            kind == CommitKind::Stamp,
988        )?;
989        body.stamped = kind != CommitKind::Unstamp;
990        // A stamp is the first approved generation, so it is also the daemon's
991        // activation point. An unstamp makes files authoritative again.
992        if matches!(kind, CommitKind::Stamp | CommitKind::Unstamp) {
993            body.daemon = DaemonPointers {
994                active: id,
995                awaiting_restart: None,
996                restart: None,
997            };
998        } else if matches!(kind, CommitKind::Approved | CommitKind::Rollback)
999            && body.awaits_restart(&entry)
1000        {
1001            body.daemon.awaiting_restart = Some(id);
1002        }
1003        // Development generations describe program placement, not a new active
1004        // configuration vector. Their tuple pointers remain untouched.
1005        if kind != CommitKind::Development {
1006            body.approved = approved;
1007            if kind == CommitKind::Unstamp {
1008                body.program_refusals.clear();
1009            } else if !body.program_refusals.is_empty() {
1010                let snapshot = crate::config_gate::GateSnapshot::from_store(&body.approved)
1011                    .map_err(StoreError::serialization)?;
1012                body.program_refusals.retain(|refusal| {
1013                    crate::config_gate::program::approved_base(&snapshot, &refusal.module)
1014                        == refusal.approved_base
1015                });
1016            }
1017            for tuple in &entry.tuples {
1018                let index = body
1019                    .versions
1020                    .iter()
1021                    .position(|(t, _)| t == tuple)
1022                    .unwrap_or_else(|| {
1023                        body.versions.push((tuple.clone(), Versions::default()));
1024                        body.versions.len() - 1
1025                    });
1026                body.versions[index].1.pending = Some(id);
1027            }
1028        }
1029        body.generations.insert(id, entry);
1030        body.observed = if kind == CommitKind::Unstamp {
1031            None
1032        } else {
1033            Some(observed)
1034        };
1035        if kind == CommitKind::Stamp {
1036            body.proposal = None;
1037        }
1038        let proposal_changed = body.rebase_proposal()?;
1039        body.prune(now_ms);
1040        self.publish(body, kind == CommitKind::Stamp, now_ms)?;
1041        if proposal_changed {
1042            self.proposal_activity();
1043        }
1044        Ok(id)
1045    }
1046
1047    fn select_stamp_mode(&mut self) -> Result<(), StoreError> {
1048        if self.backend.seal_available() {
1049            if self.backend.load()?.is_none() {
1050                self.backend.create()?;
1051            }
1052            self.envelope.integrity = IntegrityMode::Sealed;
1053        } else {
1054            self.envelope.integrity = IntegrityMode::DigestOnly;
1055        }
1056        Ok(())
1057    }
1058
1059    /// Approved recovery exits discard every record from the rejected store.
1060    /// Only a present readable keychain item's high-water survives. The caller
1061    /// supplies a newly validated file snapshot and approval, just as for stamp.
1062    pub fn recovery_exit(
1063        &mut self,
1064        mut entry: HistoryEntry,
1065        snapshot: Snapshot,
1066        now_ms: u64,
1067    ) -> Result<u64, StoreError> {
1068        if !matches!(
1069            self.state,
1070            StoreState::StoreUnverified | StoreState::StoreMissing
1071        ) || !matches!(entry.kind, CommitKind::Stamp | CommitKind::Unstamp)
1072        {
1073            return Err(StoreError::new(
1074                StoreErrorCode::InvalidState,
1075                "not a recovery exit",
1076            ));
1077        }
1078        self.select_stamp_mode()?;
1079        let revision =
1080            self.next_revision(self.envelope.integrity == IntegrityMode::Sealed, true)?;
1081        entry.generation.id = 1;
1082        let stamped = entry.kind == CommitKind::Stamp;
1083        let mut body = StoreBody {
1084            stamped,
1085            base_revision: revision,
1086            last_generation: 1,
1087            approved: snapshot,
1088            daemon: DaemonPointers {
1089                active: 1,
1090                awaiting_restart: None,
1091                restart: None,
1092            },
1093            ..StoreBody::default()
1094        };
1095        for tuple in &entry.tuples {
1096            body.versions.push((
1097                tuple.clone(),
1098                Versions {
1099                    pending: Some(1),
1100                    ..Versions::default()
1101                },
1102            ));
1103        }
1104        body.generations.insert(1, entry);
1105        body.prune(now_ms);
1106        self.pending_anchor = None;
1107        self.pending_prior_anchor = None;
1108        self.deferred_failure = None;
1109        self.unanchored_ack = None;
1110        self.publish(body, true, now_ms)?;
1111        self.warnings
1112            .push("Recovery reset history and generation ids; continuity is not guaranteed".into());
1113        Ok(1)
1114    }
1115
1116    fn proposal_activity(&mut self) {
1117        self.activities.push(StoreActivity {
1118            event: "config.proposal",
1119            detail: "Pending configuration diff changed".into(),
1120        });
1121    }
1122    /// Before stamp this is informational and never creates a store file.
1123    pub fn observe(&mut self, snapshot: Snapshot) -> Result<bool, StoreError> {
1124        self.delivery_ready()?;
1125        let mut body = self.envelope.body.clone();
1126        body.observed = Some(snapshot);
1127        let changed = body.rebase_proposal()?;
1128        let identity_changed = body.proposal != self.envelope.body.proposal;
1129        if self.state == StoreState::Stamped && identity_changed {
1130            self.publish(body, false, wall_time_ms())?;
1131        } else if self.state == StoreState::Unstamped {
1132            self.envelope.body = body;
1133        }
1134        if changed {
1135            self.proposal_activity();
1136        }
1137        Ok(changed)
1138    }
1139
1140    /// ACK/NACK for a superseded generation changes nothing. A failure restores
1141    /// the active pointer immediately, even if its durable mark must wait for an
1142    /// anchor retry. ACKs never change memory while an anchor is pending.
1143    ///
1144    /// Nothing is delivered while an earlier anchor is pending. Once repaired,
1145    /// an unanchored NACKed generation may return at most once per daemon start,
1146    /// never within one run and never after its failure is anchored. The crash
1147    /// window and persistent-keychain-failure proof is
1148    /// `config_delivery_anchor_pending_restart_before_failure_anchor_may_redeliver_once`.
1149    pub fn record_delivery(
1150        &mut self,
1151        tuple: &Tuple,
1152        generation: u64,
1153        ack: bool,
1154    ) -> Result<(), StoreError> {
1155        self.check()?;
1156        let mut body = self
1157            .deferred_failure
1158            .as_ref()
1159            .or(self.unanchored_ack.as_ref().map(|ack| &ack.visible))
1160            .unwrap_or(&self.envelope.body)
1161            .clone();
1162        let before_ack = ack.then(|| body.clone());
1163        let Some((_, versions)) = body.versions.iter_mut().find(|(t, _)| t == tuple) else {
1164            return Ok(());
1165        };
1166        if versions.pending != Some(generation) {
1167            return Ok(());
1168        }
1169        if self.pending_anchor.is_some() && ack {
1170            return Err(StoreError::new(
1171                StoreErrorCode::AnchorPending,
1172                "ACK not recorded",
1173            ));
1174        }
1175        versions.pending = None;
1176        if ack {
1177            versions.recovery = versions.active;
1178            versions.active = Some(generation);
1179        }
1180        let entry = body
1181            .generations
1182            .get_mut(&generation)
1183            .ok_or_else(|| StoreError::new(StoreErrorCode::GenerationMissing, generation))?;
1184        entry.generation.module_states.insert(
1185            tuple.module.clone(),
1186            if ack {
1187                subc_config::GenerationState::Active
1188            } else {
1189                subc_config::GenerationState::Failed
1190            },
1191        );
1192        if !ack && !entry.generation.never_redeliver.contains(&tuple.module) {
1193            entry.generation.never_redeliver.push(tuple.module.clone());
1194        }
1195        entry.outcome = if ack { "active" } else { "failed" }.into();
1196        if self.pending_anchor.is_some() {
1197            self.deferred_failure = Some(body);
1198            if !self.warnings.iter().any(|w| w.contains("redeliver")) {
1199                self.warnings.push(
1200                    "Failure held in memory while anchor is pending; restart may redeliver once"
1201                        .into(),
1202                );
1203            }
1204            return Err(StoreError::new(
1205                StoreErrorCode::AnchorPending,
1206                "failure restored in memory; durable mark pending",
1207            ));
1208        }
1209        let result = self.publish(body, false, wall_time_ms());
1210        if ack && result.is_err() && self.pending_anchor.is_some() {
1211            self.unanchored_ack = before_ack.map(|visible| UnanchoredAck {
1212                visible,
1213                tuple: tuple.clone(),
1214                generation,
1215            });
1216        }
1217        result
1218    }
1219
1220    pub fn rollback_configuration(&mut self, generation: u64) -> Result<Snapshot, StoreError> {
1221        let body = self.body()?;
1222        if body.pruned.contains_key(&generation) {
1223            return Err(StoreError::new(
1224                StoreErrorCode::GenerationPruned,
1225                generation,
1226            ));
1227        }
1228        body.generations
1229            .get(&generation)
1230            .map(|e| e.configuration.clone())
1231            .ok_or_else(|| StoreError::new(StoreErrorCode::GenerationMissing, generation))
1232    }
1233}
1234
1235impl ConfigStore {
1236    /// Persist a resumed attempt before notifying a module after daemon restart.
1237    /// Never-redeliver and superseded targets cannot be resumed.
1238    pub fn resume_delivery(&mut self, tuple: &Tuple, generation: u64) -> Result<bool, StoreError> {
1239        self.delivery_ready()?;
1240        let mut body = self.envelope.body.clone();
1241        if !body
1242            .versions
1243            .iter()
1244            .any(|(t, v)| t == tuple && v.pending == Some(generation))
1245        {
1246            return Ok(false);
1247        }
1248        let entry = body
1249            .generations
1250            .get_mut(&generation)
1251            .ok_or_else(|| StoreError::new(StoreErrorCode::GenerationMissing, generation))?;
1252        if entry.generation.never_redeliver.contains(&tuple.module) {
1253            return Ok(false);
1254        }
1255        entry.outcome = "resumed".into();
1256        self.publish(body, false, wall_time_ms())?;
1257        Ok(true)
1258    }
1259}
1260
1261fn mark_daemon_failed(entry: &mut HistoryEntry) {
1262    entry
1263        .generation
1264        .module_states
1265        .insert(DAEMON_MODULE.into(), subc_config::GenerationState::Failed);
1266    if !entry
1267        .generation
1268        .never_redeliver
1269        .iter()
1270        .any(|module| module == DAEMON_MODULE)
1271    {
1272        entry.generation.never_redeliver.push(DAEMON_MODULE.into());
1273    }
1274    entry.outcome = "failed".into();
1275}
1276
1277/// Daemon generation selection: an ordinary start boots the last active daemon
1278/// generation, and only a durable restart intent may warm up a newer one.
1279impl ConfigStore {
1280    /// Bootstrap found no usable approved daemon configuration. This run serves
1281    /// recovery; the next start verifies the store again from the start.
1282    pub(crate) fn enter_recovery(&mut self, detail: &str) {
1283        self.state = StoreState::StoreUnverified;
1284        self.warnings
1285            .push(format!("Recovery required at daemon start: {detail}"));
1286    }
1287
1288    /// The generation this daemon booted from, once bootstrap selected one.
1289    pub(crate) fn booted_generation(&self) -> Option<u64> {
1290        self.booted_generation
1291    }
1292
1293    /// Choose the generation a stamped daemon boots. A restart intent is marked
1294    /// attempted durably before its generation boots, so a start that finds an
1295    /// attempted intent knows the warm-up never became ready: that generation
1296    /// is marked failed and the last active one boots instead.
1297    pub(crate) fn select_boot_generation(&mut self) -> Result<u64, StoreError> {
1298        self.delivery_ready()?;
1299        let mut body = self.envelope.body.clone();
1300        let mut warm_up = None;
1301        let changed = match body.daemon.restart {
1302            None => false,
1303            Some(intent) if intent.attempted => {
1304                if let Some(entry) = body.generations.get_mut(&intent.generation) {
1305                    mark_daemon_failed(entry);
1306                }
1307                self.warnings.push(format!(
1308                    "Daemon restart into generation {} never became ready; it is marked failed",
1309                    intent.generation
1310                ));
1311                body.daemon.restart = None;
1312                true
1313            }
1314            Some(intent) => {
1315                if body.bootable_generation(intent.generation)
1316                    && Some(intent.generation) > body.active_daemon_generation()
1317                {
1318                    warm_up = Some(intent.generation);
1319                    body.daemon.restart = Some(RestartIntent {
1320                        attempted: true,
1321                        ..intent
1322                    });
1323                } else {
1324                    body.daemon.restart = None;
1325                }
1326                true
1327            }
1328        };
1329        let selected = warm_up.or_else(|| body.active_daemon_generation());
1330        if changed {
1331            self.publish(body, false, wall_time_ms())?;
1332        }
1333        let selected = selected.ok_or_else(|| {
1334            StoreError::new(
1335                StoreErrorCode::GenerationMissing,
1336                "no bootable approved daemon generation",
1337            )
1338        })?;
1339        self.booted_generation = Some(selected);
1340        Ok(selected)
1341    }
1342
1343    /// The daemon booted from a restart intent is serving: its generation
1344    /// becomes the daemon's active generation and the intent is spent.
1345    pub(crate) fn record_daemon_ready(&mut self) -> Result<(), StoreError> {
1346        let Some(booted) = self.booted_generation else {
1347            return Ok(());
1348        };
1349        let attempted = RestartIntent {
1350            generation: booted,
1351            attempted: true,
1352        };
1353        if self.state != StoreState::Stamped || self.envelope.body.daemon.restart != Some(attempted)
1354        {
1355            return Ok(());
1356        }
1357        let mut body = self.envelope.body.clone();
1358        body.daemon = DaemonPointers {
1359            active: booted,
1360            awaiting_restart: body.first_awaiting_restart_after(booted),
1361            restart: None,
1362        };
1363        self.publish(body, false, wall_time_ms())
1364    }
1365
1366    /// The operator is restarting the daemon. Name the newest approved
1367    /// generation still waiting for that restart, durably, before it exits.
1368    pub(crate) fn assign_daemon_restart(&mut self) -> Result<Option<u64>, StoreError> {
1369        self.delivery_ready()?;
1370        if self.state != StoreState::Stamped {
1371            return Ok(None);
1372        }
1373        let Some(generation) = self.envelope.body.restart_candidate() else {
1374            return Ok(None);
1375        };
1376        let intent = RestartIntent {
1377            generation,
1378            attempted: false,
1379        };
1380        if self.envelope.body.daemon.restart != Some(intent) {
1381            let mut body = self.envelope.body.clone();
1382            body.daemon.restart = Some(intent);
1383            self.publish(body, false, wall_time_ms())?;
1384        }
1385        Ok(Some(generation))
1386    }
1387}