Struct Classification 

pub struct Classification {
    pub point_type: ConvergencePointType,
    pub substrate: SubstrateType,
    pub horizon: Horizon,
    pub calm: CalmClassification,
    pub data_classification: DataClassification,
}

Lattice position of a Process — six orthogonal axes.

Fields

point_type: ConvergencePointType

substrate: SubstrateType

horizon: Horizon

calm: CalmClassification

data_classification: DataClassification

Implementations

impl Classification

pub fn gate_compute() -> Self

The workspace-baseline classification — a ConvergencePointType::Gate point on the SubstrateType::Compute substrate with every other axis at its Default. The (Gate, Compute) pair names an unremarkable barrier point in the Compute plane: no domain-specific structural claim (no fan-out / fan-in / broadcast / observation semantics beyond the barrier gate) and no domain-specific substrate claim (no Financial / Network / Storage / Security / Identity / Observability / Regulatory plane bringing in its own compliance baselines). The three defaulted axes ride at the intentional workspace baseline the sibling closed-set primitives already own: Horizon at HorizonKind::Bounded (terminates naturally, no asymptotic metric axes required), CalmClassification::Monotone (no coordination required per CALM), and DataClassification::Internal (access-controlled but not externally regulated).

Pre-lift the six-line Classification { point_type: Gate, substrate: Compute, horizon: Default::default(), calm: Default::default(), data_classification: Default::default() } struct-literal recurred at TEN sites past the ★★ PRIME-DIRECTIVE ≥ 2 duplication threshold — one production consumer plus nine test-fixture callsites spread across four crates, each restating the SAME (Gate, Compute) baseline verbatim:

• crate::ephemeral::default_ephemeral_class — the substitute [EphemeralSpec::into::<crate::crd::ProcessSpec>] fills into crate::crd::ProcessSpec::classification when the operator omits an explicit :classification slot on (defephemeral …). The one PRODUCTION consumer of the shape — a regression that drifted its point-type or substrate axis silently retargets every unadorned ephemeral to a different plane.
• crate::crd’s + crate::lib’s + crate::lifetime_clock’s + tatara_reconciler::{claim,render}’s + tatara_pool_reconciler:: controller_pool’s empty_spec / empty_process_spec / ephemeral_process / permanent_process test-fixture helpers + inline ProcessSpec literals — nine test-fixture callsites restating the SAME six-line struct-literal at the same shape.

Post-lift every callsite reads Classification::gate_compute(); a future workspace-wide baseline shift (a new Horizon default, a promotion of Compute to a compound baseline that pre-fills a canonical CalmClassification, a per-baseline compliance overlay stamping through the classification, or a rename of either axis enum) lands at ONE substrate function here and every downstream consumer inherits the upgrade mechanically. The current pin ties the three defaulted axes to the sibling closed-set defaults (HorizonKind::Bounded, CalmClassification::Monotone, DataClassification::Internal) so a future change to any sibling default surfaces at this primitive’s tests rather than as silent drift across ten independent callsites.

Sibling to the _or_default / _or_placeholder primitive family on crate::prelude::Process on the (return-form × axis) axis — those primitives own the borrow-form projections off a live Process; this one owns the construction shape for a fresh crate::crd::ProcessSpec whose classification axis is unremarkable. A future peer Classification::observe_observability() or similar named variant lands as a sibling method here when a second unremarkable-baseline shape opens.

Theory anchor: THEORY.md §VI.1 (generation over composition — the six-line struct-literal shape recurred at TEN hand-authored sites past the ★★ PRIME-DIRECTIVE ≥ 2 duplication trigger and is lifted onto ONE workspace-wide owner here). THEORY.md §II.1 invariant 5 (composition preserves proofs — a regression that drifted the baseline axis choice at only one consumer, or that broke the sibling-default correspondence, surfaces at this primitive’s tests rather than as silent operator-visible skew between the ephemeral sugar substitute and the ten downstream test-fixtures whose assertions depend on the shape).

pub fn has_point_type(&self, kind: ConvergencePointType) -> bool

Closed-set-driven presence probe — does this Classification carry the given ConvergencePointType discriminator on its Self::point_type slot? The ONE substrate primitive that owns the (Classification, ConvergencePointType) -> bool scalar-carrier walk shape.

Third scalar-carrier peer on the presence-probe axis

Peer of crate::spec::SignalPolicy::has_sighup_strategy and crate::encapsulates::EncapsulatesSpec::has_mode — all three probe a scalar closed-set-discriminator field on an inner crate::crd::ProcessSpec struct via a one-line self.<field> == kind body. Together they compose the SCALAR-CARRIER stratum of the workspace-wide closed-set-driven presence-probe algebra (the workspace-wide algebra spans three underlying representation kinds — Option-slot, slice, scalar — see the crate::spec::SignalPolicy::has_sighup_strategy docstring for the full-shape rundown; this method is the third scalar-carrier instance).

Semantics — VARIANT match, not POPULATED slot

has_point_type(kind) returns true iff self.point_type == kind. Distinct from BOTH prior scalar-carrier peers on the (parent-shape × child-shape) axis:

• crate::spec::SignalPolicy::has_sighup_strategy lives on a non-Option, DEFAULTED parent (SignalPolicy: Default) with a defaulted scalar child (SighupStrategy: Default = Reconverge) — a default carrier reads true for the default variant only.
• crate::encapsulates::EncapsulatesSpec::has_mode lives on an OPTION parent (spec.encapsulates: Option<EncapsulatesSpec>) with a defaulted scalar child (EncapsulationMode: Default = Manage) — a bare None parent reads false for every variant.
• has_point_type lives on a REQUIRED, non-Option, NON-DEFAULT parent (Classification has no impl Default) with a NON-DEFAULT scalar child (ConvergencePointType has no impl Default) — every well-formed crate::crd::ProcessSpec carries a Classification whose point_type slot is deliberately chosen by the operator, so the probe returns true on exactly ONE variant per spec and false on the other seven, with no default-arm short-circuit shortcut.

This closes the (required-parent × required-scalar-child) corner of the workspace-wide closed-set-driven presence-probe algebra at its first substrate primitive.

Compounding

A future closed-set-discriminator scalar field on Classification (a peer has_substrate, has_calm, has_data_classification — the four remaining classification-axis closed sets) lands as ONE peer inherent method with the same one-line self.<field> == kind body and routes through the same strip_and_classify_prefixed_kind::<K, _> shape in tatara-check. A future ConvergencePointType variant (a hypothetical Demux / Mux / Pipeline for finer topology carving) reaches every downstream through ONE ALL entry on the closed set with the probe body untouched.

Theory anchor: THEORY.md §II.1 invariant 5 — composition preserves proofs; the scalar-carrier presence-probe body lives at ONE substrate site so every downstream (point-type-<kind> require-tag family in tatara-check, closed-set audit dispatchers, future variant additions on ConvergencePointType) binds through the SAME shape rather than restating the classification.point_type == kind closure body at each callsite. THEORY.md §VI.1 — generation over composition; a future ConvergencePointType variant lands at ONE ALL entry + ONE as_str arm on the closed set and the probe picks it up mechanically without further per-consumer edits.

pub fn has_substrate(&self, kind: SubstrateType) -> bool

Closed-set-driven presence probe — does this Classification carry the given SubstrateType discriminator on its Self::substrate slot? The ONE substrate primitive that owns the (Classification, SubstrateType) -> bool scalar-carrier walk shape.

Fourth scalar-carrier peer on the presence-probe axis

Peer of crate::spec::SignalPolicy::has_sighup_strategy, crate::encapsulates::EncapsulatesSpec::has_mode, and Self::has_point_type — all four probe a scalar closed-set- discriminator field on an inner crate::crd::ProcessSpec struct via a one-line self.<field> == kind body. Together they compose the SCALAR-CARRIER stratum of the workspace-wide closed-set-driven presence-probe algebra (the workspace-wide algebra spans three underlying representation kinds — Option- slot, slice, scalar — see the crate::spec::SignalPolicy::has_sighup_strategy docstring for the full-shape rundown; this method is the fourth scalar- carrier instance).

Semantics — VARIANT match, not POPULATED slot

has_substrate(kind) returns true iff self.substrate == kind. FIRST co-tenant on the (required-parent × required- scalar-child) corner of the algebra with Self::has_point_type — both probe REQUIRED, non-Option, NON-DEFAULT slots on the same Classification parent whose two required axes carry no Default impl, so exactly ONE of the eight SubstrateType variants and exactly ONE of the eight ConvergencePointType variants answer true per well-formed crate::crd::ProcessSpec, with no default-arm short-circuit shortcut. Distinct from the two prior scalar-carrier peers on the (parent-shape × child- shape) axis: has_sighup_strategy lives on a non-Option, DEFAULTED parent (crate::spec::SignalPolicy carries #[derive(Default)]) with a defaulted scalar child (crate::signal::SighupStrategy defaults to crate::signal::SighupStrategy::Reconverge); has_mode lives on an OPTION parent (spec.encapsulates: Option<EncapsulatesSpec>) with a defaulted scalar child (crate::encapsulates::EncapsulationMode defaults to crate::encapsulates::EncapsulationMode::Manage).

This POPULATES the (required-parent × required-scalar-child) corner of the workspace-wide closed-set-driven presence-probe algebra at its SECOND substrate primitive after Self::has_point_type opened the corner, pinning the corner as a proven-repeatable primitive shape rather than a single- example curiosity.

Compounding

A future closed-set-discriminator scalar field on Classification (a peer has_calm on CalmClassification, has_data_classification on DataClassification — the two remaining defaulted-scalar-child classification-axis closed sets) lands as ONE peer inherent method with the same one-line self.<field> == kind body and routes through the same strip_and_classify_prefixed_kind::<K, _> shape in tatara-check. A future SubstrateType variant (a hypothetical Consensus for governance substrates, Physical for hardware substrates, Cache for ephemeral memoization substrates) reaches every downstream through ONE ALL entry on the closed set with the probe body untouched.

Theory anchor: THEORY.md §II.1 invariant 5 — composition preserves proofs; the scalar-carrier presence-probe body lives at ONE substrate site so every downstream (substrate-<kind> require-tag family in tatara-check, closed-set audit dispatchers, future variant additions on SubstrateType) binds through the SAME shape rather than restating the classification.substrate == kind closure body at each callsite. THEORY.md §VI.1 — generation over composition; a future SubstrateType variant lands at ONE ALL entry + ONE as_str arm on the closed set and the probe picks it up mechanically without further per-consumer edits.

pub fn has_calm(&self, kind: CalmClassification) -> bool

Closed-set-driven presence probe — does this Classification carry the given CalmClassification discriminator on its Self::calm slot? The ONE substrate primitive that owns the (Classification, CalmClassification) -> bool scalar-carrier walk shape.

Fifth scalar-carrier peer on the presence-probe axis

Peer of crate::spec::SignalPolicy::has_sighup_strategy, crate::encapsulates::EncapsulatesSpec::has_mode, Self::has_point_type, and Self::has_substrate — all five probe a scalar closed-set-discriminator field on an inner crate::crd::ProcessSpec struct via a one-line self.<field> == kind body. Together they compose the SCALAR-CARRIER stratum of the workspace-wide closed-set-driven presence-probe algebra (the workspace-wide algebra spans three underlying representation kinds — Option-slot, slice, scalar — see the crate::spec::SignalPolicy::has_sighup_strategy docstring for the full-shape rundown; this method is the fifth scalar-carrier instance).

Semantics — VARIANT match, not POPULATED slot

has_calm(kind) returns true iff self.calm == kind. FIRST occupant on a FRESH corner of the (parent-shape × child-shape) axis: a REQUIRED, non-Option, NON-DEFAULT parent (Classification has no impl Default because its two required axes point_type/substrate carry no default) combined with a DEFAULTED scalar child (CalmClassification defaults to CalmClassification::Monotone via #[default]). Distinct from every prior scalar-carrier peer on the (parent-shape × child-shape) axis:

• crate::spec::SignalPolicy::has_sighup_strategy lives on a non-Option, DEFAULTED parent (crate::spec::SignalPolicy carries #[derive(Default)]) with a defaulted scalar child (crate::signal::SighupStrategy defaults to crate::signal::SighupStrategy::Reconverge) — a bare SignalPolicy reads true on the default variant only.
• crate::encapsulates::EncapsulatesSpec::has_mode lives on an OPTION parent (spec.encapsulates: Option<EncapsulatesSpec>) with a defaulted scalar child (crate::encapsulates::EncapsulationMode defaults to crate::encapsulates::EncapsulationMode::Manage) — a bare None parent reads false for every variant.
• Self::has_point_type + Self::has_substrate both live on the REQUIRED, non-Option, NON-DEFAULT Classification parent with a NON-DEFAULT scalar child — every well-formed crate::crd::ProcessSpec carries a Classification whose corresponding slot was deliberately chosen by the operator, so exactly ONE of the eight variants answers true per spec.
• has_calm lives on the REQUIRED, non-Option, NON-DEFAULT Classification parent with a DEFAULTED scalar child (CalmClassification::Monotone is the Default via #[default]) — a bare Classification filled via ..Default::default() on the defaulted axes reads true for the default variant (CalmClassification::Monotone) and false for every other. Exactly ONE of the two variants answers true per spec, and the default-arm short-circuit is present (the operator can DECLINE to name the CALM axis and the spec still answers true on the default variant).

This OPENS the (required-parent × defaulted-scalar-child) corner of the workspace-wide closed-set-driven presence-probe algebra at its first substrate primitive — a corner distinct from all four prior scalar-carrier peers (which sit on the three prior corners: defaulted-parent × defaulted-child, Option-parent × defaulted-child, required-parent × required-child).

Compounding

A future closed-set-discriminator scalar field on Classification whose child carries #[derive(Default)] (a peer has_data_classification on DataClassification, whose default is DataClassification::Internal via #[default] — the remaining classification-axis closed set on a defaulted-scalar-child slot) lands as ONE peer inherent method with the same one-line self.<field> == kind body and routes through the same strip_and_classify_prefixed_kind::<K, _> shape in tatara-check. A future CalmClassification variant (a hypothetical ConditionallyMonotone for ops that are monotone under a witness, like CRDT joins under a fixed schema) reaches every downstream through ONE ALL entry on the closed set with the probe body untouched.

Theory anchor: THEORY.md §II.1 invariant 5 — composition preserves proofs; the scalar-carrier presence-probe body lives at ONE substrate site so every downstream (calm-<kind> require-tag family in tatara-check, closed-set audit dispatchers, future variant additions on CalmClassification) binds through the SAME shape rather than restating the classification.calm == kind closure body at each callsite. THEORY.md §VI.1 — generation over composition; a future CalmClassification variant lands at ONE ALL entry + ONE as_str arm on the closed set and the probe picks it up mechanically without further per-consumer edits.

pub fn has_data_classification(&self, kind: DataClassification) -> bool

Closed-set-driven presence probe — does this Classification carry the given DataClassification discriminator on its Self::data_classification slot? The ONE substrate primitive that owns the (Classification, DataClassification) -> bool scalar-carrier walk shape.

Sixth scalar-carrier peer on the presence-probe axis

Peer of crate::spec::SignalPolicy::has_sighup_strategy, crate::encapsulates::EncapsulatesSpec::has_mode, Self::has_point_type, Self::has_substrate, and Self::has_calm — all six probe a scalar closed-set- discriminator field on an inner crate::crd::ProcessSpec struct via a one-line self.<field> == kind body. Together they compose the SCALAR-CARRIER stratum of the workspace-wide closed-set-driven presence-probe algebra (the workspace-wide algebra spans three underlying representation kinds — Option- slot, slice, scalar — see the crate::spec::SignalPolicy::has_sighup_strategy docstring for the full-shape rundown; this method is the sixth scalar- carrier instance).

Semantics — VARIANT match, not POPULATED slot

has_data_classification(kind) returns true iff self.data_classification == kind. SECOND co-tenant on the (required-parent × defaulted-scalar-child) corner of the algebra alongside Self::has_calm — both probe REQUIRED, non-Option, NON-DEFAULT Classification parent slots with a DEFAULTED scalar child (DataClassification defaults to DataClassification::Internal via #[default], sibling to CalmClassification::Monotone’s #[default]), so exactly ONE of the six DataClassification variants answers true per spec AND the default-arm short-circuit is present (a Classification filled via ..Default::default() on the data_classification axis reads true on the default variant DataClassification::Internal and false on every other).

This POPULATES the (required-parent × defaulted-scalar-child) corner of the workspace-wide closed-set-driven presence-probe algebra at its SECOND substrate primitive after Self::has_calm opened the corner, pinning the corner as a proven-repeatable primitive shape rather than a single-example curiosity. The corner-property contract (“bare Classification reads true on the default variant”) now walks TWO independent defaulted-scalar-child slots on the SAME Classification parent — a regression that promoted a different DataClassification variant to #[default] (or wired the arm to a fixed variant answer) fails HERE at ONE narrow substrate site before drifting through every unadorned Process’s baseline data-classification answer.

Compounding

This method exhausts the four scalar closed-set-discriminator axes on Classification (Self::has_point_type, Self::has_substrate, Self::has_calm, and Self::has_data_classification) — the six-axis classification lattice publishes ALL FOUR of its scalar-carrier presence probes at ONE substrate site each. The remaining two axes (horizon — a nested struct threading HorizonKind through horizon.kind; the sixth axis is variant-dependent on the HorizonKind::Asymptotic arm) live on nested-struct-scalar slots rather than the direct-scalar corner the four current peers span — the Self::has_horizon_kind peer opens that fresh (required-parent × nested-struct-scalar-child) corner with the same has(kind) shape composed through one struct hop. A future DataClassification variant (a hypothetical seventh variant beyond Public / Internal / Confidential / Pii / Phi / Pci — say a TradeSecret bucket for competitive-sensitive data, or an Anonymized bucket for pseudonymized-PII whose regulatory posture differs) reaches every downstream through ONE ALL entry on the closed set + ONE as_str arm + ONE sensitivity_rank arm + one arm per predicate with the probe body untouched.

Theory anchor: THEORY.md §II.1 invariant 5 — composition preserves proofs; the scalar-carrier presence-probe body lives at ONE substrate site so every downstream (data-classification-<kind> require-tag family in tatara-check, closed-set audit dispatchers, future variant additions on DataClassification) binds through the SAME shape rather than restating the classification.data_classification == kind closure body at each callsite. THEORY.md §VI.1 — generation over composition; a future DataClassification variant lands at ONE ALL entry + ONE as_str arm on the closed set and the probe picks it up mechanically without further per-consumer edits.

pub fn has_horizon_kind(&self, kind: HorizonKind) -> bool

Closed-set-driven presence probe — does this Classification carry the given HorizonKind discriminator on its Self::horizon.kind slot? The ONE substrate primitive that owns the (Classification, HorizonKind) -> bool nested-struct- scalar-carrier walk shape.

Seventh peer on the presence-probe axis — first on a fresh corner

Peer of crate::spec::SignalPolicy::has_sighup_strategy, crate::encapsulates::EncapsulatesSpec::has_mode, Self::has_point_type, Self::has_substrate, Self::has_calm, and Self::has_data_classification on the workspace-wide closed-set-driven presence-probe algebra — the four scalar-carrier peers on Classification all read a closed-set discriminator DIRECTLY off a scalar Classification slot (point_type, substrate, calm, data_classification). has_horizon_kind instead threads through a NESTED-STRUCT intermediary (Horizon, the defaulted nested struct owning the horizon axis on the six-axis classification lattice) to reach a scalar HorizonKind discriminator on horizon.kind. This OPENS the (required-parent × nested- struct-scalar-child) corner of the algebra at its FIRST substrate primitive — a fresh corner distinct from all four corner-property-exhaustive scalar-carrier peers on Classification.

Semantics — VARIANT match on the nested scalar, not POPULATED nested struct

has_horizon_kind(kind) returns true iff self.horizon.kind == kind. The nested Horizon struct carries Default via #[derive(Default)] and its kind field defaults to HorizonKind::Bounded via #[default], so a Classification filled via ..Default::default() on the horizon axis reads true on the default kind HorizonKind::Bounded and false on HorizonKind::Asymptotic. The default-arm short-circuit is therefore present at this corner too — but through the extra struct hop the peer scalar-carrier peers on the defaulted- child corner (has_calm, has_data_classification) walk directly. A regression that dropped #[default] on HorizonKind, or that replaced Horizon::default() in Classification::gate_compute with an explicit non-Bounded kind, surfaces at this primitive’s tests before drifting through every unadorned Process’s baseline horizon answer.

Compounding

This method OPENS the (required-parent × nested-struct-scalar- child) corner of the workspace-wide closed-set-driven presence-probe algebra, distinct from the four corner-property- exhaustive scalar-carrier peers on Classification (Self::has_point_type, Self::has_substrate, Self::has_calm, Self::has_data_classification) whose bodies read a closed-set discriminator directly off a scalar slot. A future co-tenant on this fresh corner (a peer probe on another nested-struct’s scalar discriminator, e.g. a hypothetical has_optimization_direction reaching spec.classification.horizon.direction.unwrap_or_default(), or a nested-struct-scalar discriminator on a different ProcessSpec field’s inner struct) lands as ONE peer inherent method with the same two-hop self.<outer>.<inner> == kind body and routes through the same strip_and_classify_prefixed_kind::<K, _> shape in tatara-check. A future HorizonKind variant (a hypothetical Periodic sentinel for “terminates on each window boundary then re-arms”, pre-flagged on the closed set’s ALL docstring) reaches every downstream through ONE ALL entry + one as_str arm + one terminates arm + one requires_metric_axes arm on the closed set with the probe body untouched.

Theory anchor: THEORY.md §II.1 invariant 5 — composition preserves proofs; the nested-struct-scalar-carrier presence- probe body lives at ONE substrate site so every downstream (horizon-<kind> require-tag family in tatara-check, future audit dispatchers walking HorizonKind::ALL, future variant additions on HorizonKind) binds through the SAME has(kind) shape rather than restating the classification.horizon.kind == kind closure body at each callsite. THEORY.md §VI.1 — generation over composition; a future HorizonKind variant lands at ONE ALL entry + ONE as_str arm on the closed set and the probe picks it up mechanically without further per-consumer edits.

pub fn has_optimization_direction(&self, kind: OptimizationDirection) -> bool

Closed-set-driven presence probe — does this Classification carry the given OptimizationDirection discriminator on its Self::horizon.direction slot (with the substrate Option::unwrap_or_default treating None as the closed set’s #[default] Minimize)? The ONE substrate primitive that owns the (Classification, OptimizationDirection) -> bool nested- struct-Option-scalar-carrier walk shape.

Second occupant on the nested-struct-scalar-child corner —

the Option-hop co-tenant

Peer of Self::has_horizon_kind on the (required-parent × nested-struct-scalar-child) corner opened by that method — same two-hop composition through the nested defaulted Horizon intermediary, but the inner scalar slot is direction: Option<OptimizationDirection> (an Option-hop past the same nested Horizon) rather than a bare scalar. The corner therefore admits BOTH direct nested-scalar shapes (Horizon carries kind: HorizonKind directly, Self::has_horizon_kind walks it) AND Option-nested-scalar shapes (Horizon carries direction: Option<OptimizationDirection>, this method walks it through Option::unwrap_or_default), pinning the corner as a proven-repeatable primitive shape rather than a single- example curiosity. Every prior scalar-carrier peer on Classification (has_point_type, has_substrate, has_calm, has_data_classification) reads a closed-set discriminator DIRECTLY off a scalar Classification slot; this method (like Self::has_horizon_kind) threads through the nested Horizon intermediary, and additionally traverses the Option-slot with unwrap_or_default so the operator’s :requires (optimization-direction-Minimize) on an unadorned baseline still answers true on the closed set’s default arm.

Semantics — VARIANT match on the Option-defaulted nested

scalar, not POPULATED Option

has_optimization_direction(kind) returns true iff self.horizon.direction.unwrap_or_default() == kind. OptimizationDirection carries #[default] Minimize via the derived Default impl, so a Process filled through Horizon::bounded (which leaves direction: None) or through Horizon::default() (same shape, direction: None) answers true on OptimizationDirection::Minimize and false on OptimizationDirection::Maximize. This mirrors the default-arm short-circuit contract every other closed-set- defaulted-child probe on Classification publishes (has_calm, has_data_classification, has_horizon_kind) — the Option-hop is soft-mapped to the closed set’s default arm rather than surfaced as a distinct presence axis. A regression that flipped OptimizationDirection’s #[default] off Minimize (which would silently invert every unadorned Asymptotic Process’s rate-window evaluator polarity — see the OptimizationDirection::Minimize variant docstring) fails at this probe’s default-arm tests before drifting through every downstream consumer.

Semantics rationale — Option-hop as default vs presence

The direction: Option<OptimizationDirection> slot on Horizon is documented as “Asymptotic only” — a Bounded horizon has no meaningful direction so the operator leaves it None. Yet the closed set carries #[default] Minimize, so a bare Bounded Process’s optimization direction reads as Minimize at every consumer downstream via Option::unwrap_or_default. That default IS the substrate’s operator-facing answer for “what direction would this Process optimize toward if it became Asymptotic without further annotation?”, and a :requires (optimization-direction- Minimize) audit at the checks.lisp surface correctly matches every unadorned Process — matching the corner-property contract every other defaulted-child probe publishes. An operator who wants a strict presence axis (is direction *actually* set?) gets that answer through a distinct future primitive (has_optimization_direction_set) that would read the is_some bit alone — orthogonal to this variant-equality probe. This method commits to the variant-equality interpretation so the corner-property contract stays uniform with the four scalar-carrier peers.

Compounding

This method POPULATES the (required-parent × nested-struct- scalar-child) corner at its SECOND substrate primitive after Self::has_horizon_kind opened it — pinning the corner as a proven-repeatable primitive shape rather than a single- example curiosity, and DEMONSTRATING that the corner admits both direct-scalar and Option-scalar traversals through the same nested-struct intermediary via the closed set’s default. A future co-tenant on this corner (a peer probe on another nested-struct’s scalar or Option-scalar discriminator, e.g. a hypothetical has_backend_port_family reaching spec.routing.as_ref().and_then(|r| r.backend.tls_issuer.as_ref()).is_some() or a nested-struct-scalar discriminator on spec.encapsulates.<some-inner>.kind) lands as ONE peer inherent method with the same two-hop self.<outer>.<inner> walk (with or without an Option-hop threading through the closed set’s Default) and routes through the same strip_and_classify_prefixed_kind::<K, _> shape in tatara-check. A future OptimizationDirection variant (a hypothetical Stabilize sentinel for “drive toward a target value”, pre-flagged on the closed set’s ALL docstring) reaches every downstream through ONE ALL entry

• one as_str arm + one prefers_lower arm + one is_improvement arm on the closed set with the probe body untouched.

Theory anchor: THEORY.md §II.1 invariant 5 — composition preserves proofs; the nested-struct-Option-scalar-carrier presence-probe body lives at ONE substrate site so every downstream (optimization-direction-<kind> require-tag family in tatara-check, future audit dispatchers walking OptimizationDirection::ALL, future variant additions on OptimizationDirection) binds through the SAME has(kind) shape rather than restating the classification.horizon.direction.unwrap_or_default() == kind closure body at each callsite. THEORY.md §VI.1 — generation over composition; a future OptimizationDirection variant lands at ONE ALL entry + ONE as_str arm on the closed set and the probe picks it up mechanically without further per-consumer edits.

Trait Implementations

impl Clone for Classification

fn clone(&self) -> Classification

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Classification

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Classification

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for Classification

fn schema_name() -> String

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 is_referenceable() -> bool

Whether JSON Schemas generated for this type should be re-used where possible using the $ref keyword.

impl PartialEq for Classification

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Classification

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 Classification