Struct ImportanceWeights 

pub struct ImportanceWeights {
    pub confidence: f64,
    pub recency: f64,
    pub recency_field: Option<String>,
}

Usage-driven importance weights of the memory-bridge blend (US-002 of EPIC-P-071): how much a pulled memory’s learned RL confidence and its batch-relative recency tilt the fused similarity ranking.

The blend only ever applies to the pool the fused vector+graph similarity already selected — confidence is not relevance, so a heavily reinforced but off-topic fact can never enter the pool through these weights. Per pulled memory the ranking key becomes fused_norm + confidence_weight·(confidence − 0.5)·2 + recency_weight·recency_norm, clock-free and deterministic (recency is min-max normalised within the pulled batch, never against wall time).

Both weights at 0.0 disable the blend entirely: the output is byte-identical to the 0.8.0 behaviour (pinned by a golden test). The defaults are active on purpose — upgrading from 0.8.0 with the default policy, RL-reinforced memories rank higher out of the box; zero the weights to restore the exact 0.8.0 ordering.

Recommended range for both weights: [0.0, 1.0] (at 1.0 a term can fully offset the similarity gap within the pool). Values outside that range are accepted verbatim, never clamped — a negative weight deliberately inverts its term (e.g. demote reinforced facts), a weight above 1.0 lets the term dominate similarity. Only the recorded decision relevance is clamped into [0, 1]; the ranking itself uses the raw blended score.

Fields

confidence: f64

Weight of the learned RL confidence (_veles_rl_*, fed by feedback). A memory with no feedback history counts as the neutral 0.5, contributing exactly 0. Default 0.2.

recency: f64

Weight of the batch-relative recency term. Inert unless Self::recency_field is also set. Default 0.1.

recency_field: Option<String>

Caller metadata key holding each memory’s numeric timestamp-like value. None (the default) disables the recency term completely — there is no standard key to guess. The scale must be monotone and homogeneous across the batch (e.g. YYYYMMDD integers as in crate::format_dated_context, or an epoch); it is documented, not verified at run time. Values are min-max normalised over the pulled memories that carry the key; a memory without the key contributes 0 (never penalised), and a degenerate batch (max == min) contributes 0 for all.

Trait Implementations

impl Clone for ImportanceWeights

fn clone(&self) -> ImportanceWeights

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ImportanceWeights

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

Formats the value using the given formatter.

impl Default for ImportanceWeights

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ImportanceWeights

where ImportanceWeights: Default,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for ImportanceWeights

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 PartialEq for ImportanceWeights

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for ImportanceWeights

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 ImportanceWeights