Struct AtomisationPolicy 

pub struct AtomisationPolicy {
    pub auto_atomise: Option<bool>,
    pub auto_atomise_threshold_cl100k: Option<u32>,
    pub auto_atomise_max_atom_tokens: Option<u32>,
    pub auto_atomise_max_retries: Option<u32>,
    pub auto_atomise_mode: Option<AutoAtomiseMode>,
}

#880 — WT-1-D + Form 2 atomisation sub-struct of GovernancePolicy. Groups the five atomisation knobs so a new Form 2 / Cluster-F knob lands on this struct without cascading through every literal site.

Fields

auto_atomise: Option<bool>

v0.7.0 WT-1-D — when Some(true), the pre_store substrate hook (AutoAtomisationHook) deferred-enqueues a curator pass on the stored memory if its body exceeds auto_atomise_threshold_cl100k. Inherits leaf-first via the namespace chain (same walk as every other field). None / Some(false) keeps the substrate quiet; the operator opts in per-namespace by setting this to Some(true) on the namespace standard’s metadata.governance blob. skip_serializing_if keeps absent-on-wire for pre-WT-1-D federation peers (zero replication drift).

auto_atomise_threshold_cl100k: Option<u32>

v0.7.0 WT-1-D — cl100k_base token threshold over which a memory_store triggers the auto-atomisation curator pass. None defers to the compiled default (500). Resolved via the same leaf-first inheritance walk; a child None inherits the nearest ancestor’s explicit Some(n).

auto_atomise_max_atom_tokens: Option<u32>

v0.7.0 WT-1-D — per-atom token budget passed to the curator when the auto-atomisation hook fires. None defers to the compiled default (200, matching AtomiserConfig::default_max_atom_tokens). Resolved via the same leaf-first inheritance walk.

auto_atomise_max_retries: Option<u32>

v0.7.0 Cluster-F (issue #767, PERF-5) — per-namespace override for the curator retry budget used by the Synchronous pre_store auto-atomise path. None defers to the compiled default AtomiserConfig::sync_curator_max_retries (1 — chosen to keep the operator’s memory_store latency envelope tight; the deferred path keeps the full 3-retry budget because it runs on a detached worker thread).

Operators who need higher resilience on a specific Synchronous-mode namespace (at the cost of a longer worst-case envelope) raise this explicitly. Resolved via the same leaf-first inheritance walk as every other field on this struct.

auto_atomise_mode: Option<AutoAtomiseMode>

v0.7.x Form 2 (Batman framework) — atomisation execution mode.

• None / Some(Off) → no atomisation occurs (overrides any auto_atomise flag).
• Some(Deferred) → legacy WT-1-D behaviour: curator runs on a detached worker thread AFTER memory_store returns. Source is embedded as one blob before the curator round-trip lands.
• Some(Synchronous) → Form 2 alignment: SKIP source embedding, run the curator synchronously inside memory_store, atoms get their normal embed-on-insert path, source is archived with atomised_into > 0 BEFORE the response returns.

Backward compatibility: when this field is absent and auto_atomise = Some(true) is set, the resolver implicitly maps to Some(Deferred) so v0.7.0 pre-Form-2 deployments keep their existing behaviour. See GovernancePolicy::effective_auto_atomise_mode.

Trait Implementations

impl Clone for AtomisationPolicy

fn clone(&self) -> AtomisationPolicy

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AtomisationPolicy

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

Formats the value using the given formatter.

impl Default for AtomisationPolicy

fn default() -> AtomisationPolicy

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for AtomisationPolicy

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for AtomisationPolicy

impl PartialEq for AtomisationPolicy

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

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 AtomisationPolicy