Struct Timings 

pub struct Timings {
    pub bind_grace: Duration,
    pub probe_timeout: Duration,
    pub join_timeout: Duration,
    pub busy_grace: Duration,
    pub read_deadline: Duration,
    pub idle: Duration,
}

The timings above are the defaults. What a process actually judges a lease contest by is declared in .ai/repo/policy.yaml’s server: block and read once, here.

They were compiled constants until 2026-09-15: unchangeable without a rebuild, stated nowhere a reader would look, and invisible to every projection — while probe_timeout is the number that decides whether a live but slow owner keeps its lease or is taken over while it is still serving. That is a decision about how this repository is supervised, not an implementation detail, so it belongs in the model.

A OnceLock, because a process reads one policy: the repository is opened once and the answer must not change underneath a contest that is already being judged. Absent keys keep the constants, so a policy that cannot be read does not silently change behaviour.

use majordomus_cli::lease::{
    Timings, BIND_GRACE, BUSY_GRACE, IDLE, JOIN_TIMEOUT, PROBE_TIMEOUT, READ_DEADLINE,
};
// the defaults are the compiled constants, one for one
let t = Timings::default();
assert_eq!(t.bind_grace, BIND_GRACE);
assert_eq!(t.probe_timeout, PROBE_TIMEOUT);
assert_eq!(t.join_timeout, JOIN_TIMEOUT);
assert_eq!(t.busy_grace, BUSY_GRACE);
assert_eq!(t.read_deadline, READ_DEADLINE);
assert_eq!(t.idle, IDLE);
// a busy owner is given up on before the election that waits on it gives up itself
assert!(t.busy_grace < t.join_timeout);

Fields

bind_grace: Duration

server.bind_grace_seconds:

probe_timeout: Duration

server.probe_timeout_seconds:

join_timeout: Duration

server.join_timeout_seconds:

busy_grace: Duration

server.busy_grace_seconds:

read_deadline: Duration

server.read_deadline_seconds:

idle: Duration

server.idle_seconds:

Implementations

impl Timings

pub fn from_policy(policy: &ServerPolicy) -> Self

What a declaration means, as a value rather than as a side effect.

The mapping is the part that can be wrong; the OnceLock below is plumbing. Kept separate so it can be tested directly — a test that went through the lock would depend on which test ran first, since a process reads one policy by construction.

use majordomus_cli::lease::Timings;
use majordomus_cli::policy::ServerPolicy;
use std::time::Duration;

// an empty declaration keeps every default
assert_eq!(Timings::from_policy(&ServerPolicy::default()), Timings::default());

// and a declared value is the one used, rather than the constant
let declared = ServerPolicy {
    probe_timeout_seconds: Some(9),
    ..ServerPolicy::default()
};
let t = Timings::from_policy(&declared);
assert_eq!(t.probe_timeout, Duration::from_secs(9));
assert_ne!(t.probe_timeout, Timings::default().probe_timeout);
// the keys it says nothing about are untouched
assert_eq!(t.bind_grace, Timings::default().bind_grace);

// the idle timeout is declared beside the others (I2701)
let declared = ServerPolicy { idle_seconds: Some(3), ..ServerPolicy::default() };
assert_eq!(Timings::from_policy(&declared).idle, Duration::from_secs(3));

Trait Implementations

impl Clone for Timings

fn clone(&self) -> Timings

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for Timings

impl Debug for Timings

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Timings

fn default() -> Self

Returns the “default value” for a type.

impl Eq for Timings

impl PartialEq for Timings

fn eq(&self, other: &Timings) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Timings