Enum Freshness 

pub enum Freshness {
    Fresh,
    Aging,
    Stale,
    Unknown,
    Invalid,
}

How old a record is, judged against session.freshness in the policy.

This is the second of two independent judgements every record carries, and it exists because the first one cannot answer this question. Divergence says where a record’s commit sits relative to HEAD; advanced means that commit is an ancestor of this one, which sounds like agreement and is identically true on the day the record is written and a month later. Between 2026-09-05 and 2026-09-11 this repository served a handover that was advanced and six days dead, and every surface that read this model — MCP, the HTTP API, the Cockpit — presented its Next Action as the thing to do (ADR 0052).

The thresholds are policy and are read, never restated here: a constant in this file would be a second source of truth for a number the policy owns, and a repository whose policy predates the key is reported as Freshness::Unknown naming the missing key rather than judged against a default nobody declared.

The five words divide into two groups, and the division is the one a caller acts on: fresh and aging are current and may be presented as the instruction, stale and invalid must be shown as history, and unknown is neither — a record nobody can date is not thereby an old record, and treating it as one would quietly discard a briefing that is perfectly good. Freshness::history is that division, and it is the only place it is decided.

use majordomus_cli::capability::builtin::continuity::Freshness;

// the two renderings are one value: the serialised word is the word `as_str` gives,
// so a reader who met `stale` from MCP and from the command line met one fact
let stale = serde_json::to_value(Freshness::Stale).unwrap();
assert_eq!(stale, serde_json::json!("stale"));
assert_eq!(stale.as_str(), Some(Freshness::Stale.as_str()));

// and the division a caller acts on: absence of a judgement is not a bad judgement
assert!(Freshness::Stale.history() && Freshness::Invalid.history());
assert!(!Freshness::Unknown.history(), "undated is not old");
assert!(!Freshness::Fresh.history() && !Freshness::Aging.history());

Variants

Fresh

Inside session.freshness.fresh_minutes. Current; act on it.

Aging

Between the two thresholds. Still current, but its age is worth stating.

Stale

At or beyond session.freshness.stale_minutes. History, never current.

Unknown

Nothing to judge it by: no timestamp, or no thresholds declared.

Invalid

A timestamp that does not parse, or one in the future.

Implementations

impl Freshness

pub fn as_str(self) -> &'static str

The word this verdict is reported and serialised under, which is the shell tool’s own vocabulary rather than a second one invented here — a reader who meets aging from a briefing and from this executable has met one fact, not two.

use majordomus_cli::capability::builtin::continuity::Freshness;
assert_eq!(Freshness::Stale.as_str(), "stale");
// the serialised form is this word and not a second rendering of the same value
assert_eq!(
    serde_json::to_value(Freshness::Aging).unwrap(),
    serde_json::json!(Freshness::Aging.as_str()),
);

pub fn history(self) -> bool

Whether a record this old must be shown as history rather than as the current instruction. unknown is not history: a record with no timestamp is not thereby old.

use majordomus_cli::capability::builtin::continuity::Freshness;
assert!(Freshness::Stale.history());
assert!(!Freshness::Unknown.history());

Trait Implementations

impl Clone for Freshness

fn clone(&self) -> Freshness

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Freshness

impl Debug for Freshness

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Freshness

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Freshness

impl JsonSchema for Freshness

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl Ord for Freshness

fn cmp(&self, other: &Freshness) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Freshness

fn eq(&self, other: &Freshness) -> 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 PartialOrd for Freshness

fn partial_cmp(&self, other: &Freshness) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for Freshness

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Freshness