Enum Tier 

pub enum Tier {
    Task,
    Governance,
    Source,
    Decision,
    Knowledge,
    History,
}

Where an entry sits in the order the budget spends in.

The order is this repository’s own: lib/context.sh assembles its sections “in authority order, highest first, because a worker that runs out of budget must lose the least reliable evidence rather than the most: git, then the task and its policy, then blockers, then authored records, then event history.” These six tiers are that sentence, applied to objects instead of to sections.

The derived Ord is load-bearing: the variants are declared in authority order, so < means “spent before” and “harder to drop”, and the budget’s ordering is a plain sort rather than a table mapping tiers to ranks. A variant added in the wrong place would silently re-rank the whole answer, which is why the declaration order is the one thing about this enum to be careful with.

use majordomus_cli::devcontext::Tier;

// the declaration order *is* the order the budget spends in
let mut sorted = Tier::ORDER.to_vec();
sorted.sort();
assert_eq!(sorted, Tier::ORDER.to_vec());

// so the strongest authority is the smallest, and it is the one never dropped
assert_eq!(Tier::ORDER.iter().copied().min(), Some(Tier::Task));
assert!(Tier::Task < Tier::Governance && Tier::Governance < Tier::History);

// and the serialised word is the lowercase one the report is read under
assert_eq!(
    serde_json::to_value(Tier::Governance).unwrap(),
    serde_json::json!(Tier::Governance.as_str()),
);

Variants

Task

What was asked for: the issue, its milestone, the paths named, the intent. Never dropped — a context that lost the thing it was compiled about is not a smaller answer, it is the wrong one.

Governance

What the work will be judged against: the policy, the scope, the directory contracts that reach the named paths, and the rules. A blocking rule is never dropped.

Source

The code and the cases the work touches.

Decision

The architectural decisions already in force over it.

Knowledge

What a previous session left: handovers, session records, curated knowledge.

History

Supporting evidence: use cases, claims, features, and the rest of the layer.

Implementations

impl Tier

pub const ORDER: &'static [Tier]

Every tier, in the order the budget spends in.

use majordomus_cli::devcontext::Tier;
assert_eq!(Tier::ORDER.len(), 6);
assert_eq!(Tier::ORDER[0], Tier::Task);

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

The word this tier is reported under.

use majordomus_cli::devcontext::Tier;
assert_eq!(Tier::Governance.as_str(), "governance");

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

What this tier is for, in one line, so that a reader of the answer never has to find this file.

This is carried into the answer — TierSpend::meaning is this string — rather than left for a consumer to look up, because the per-tier spend is read by people who are deciding what to raise the budget for and “knowledge: 4 excluded” is not actionable without knowing what the tier holds.

use majordomus_cli::devcontext::Tier;

// it explains the tier rather than naming it, so it is never just the word again
for t in Tier::ORDER {
    assert!(t.meaning().len() > t.as_str().len(), "{} restates itself", t.as_str());
}

// and it says what is actually in there
assert!(Tier::Governance.meaning().contains("policy"));
assert!(Tier::Decision.meaning().contains("architectural decisions"));

Trait Implementations

impl Clone for Tier

fn clone(&self) -> Tier

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Tier

impl Debug for Tier

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Tier

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Tier

impl JsonSchema for Tier

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 Tier

fn cmp(&self, other: &Tier) -> 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 Tier

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

fn partial_cmp(&self, other: &Tier) -> 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 Tier

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 Tier