Struct RetrievalPlan 

pub struct RetrievalPlan {

    pub plan_id: PlanId,
    pub turn_id: TurnId,
    pub generation: u64,
    pub requires_memory: bool,
    pub confidence: f32,
    pub intent: RetrievalIntent,
    pub entities: Vec<RetrievalEntity>,
    pub topics: Vec<String>,
    pub predicates: Vec<CanonicalPredicate>,
    pub lexical_queries: Vec<String>,
    pub scopes: Vec<MemoryKind>,
    pub kind_filter: Vec<MemoryKind>,
    pub subject_hint: Option<String>,
    pub predicate_hint: Option<String>,
    pub temporal: Option<TemporalConstraint>,
    pub source_transcript_hash: String,
}

A transient plan for one turn’s retrieval.

Fields

plan_id: PlanId

Plan identity.

turn_id: TurnId

The turn the plan was derived from.

generation: u64

The generation the plan was derived at.

requires_memory: bool

Whether memory should be consulted at all.

confidence: f32

Confidence in that judgement.

intent: RetrievalIntent

What the user appears to want.

entities: Vec<RetrievalEntity>

Entities of interest.

topics: Vec<String>

Topical terms.

predicates: Vec<CanonicalPredicate>

Canonical predicates of interest.

lexical_queries: Vec<String>

Independent lexical queries to run and fuse.

scopes: Vec<MemoryKind>

Memory kinds worth searching — a hint used for explanation, never a filter. See kind_filter for the restricting form.

kind_filter: Vec<MemoryKind>

A hard kind restriction, set only when a caller explicitly asked for one.

subject_hint: Option<String>

Whose fact the caller believes this is — the subject surface form.

A hint, never a restriction: records matching it are boosted in the fusion, records that do not are still returned. That asymmetry is the whole design, and it is measured. Over 93 questions, a correct about+attribute pair applied softly takes top-5 from 79 to 91; a wrong one costs one question. Applied as a hard filter, a correct pair reaches the same 91 and a wrong one returns nothing at all — 0 of 93, with the answer absent from the candidate set every single time.

Break-even follows from that: filtering softly beats not filtering once the caller is right 8% of the time, where filtering hard needs 87%. See tests/filter_dsl_probe.rs.

predicate_hint: Option<String>

Which attribute of the subject — the canonical predicate.

Same soft semantics as subject_hint, and the more valuable of the two: a model shown memory_map names the right predicate 69% of the time against 2% without it.

temporal: Option<TemporalConstraint>

Time window, if the user named one.

source_transcript_hash: String

Hash of the transcript the plan came from, for cache keying.

Implementations

impl RetrievalPlan

pub fn skip(turn_id: TurnId, generation: u64, transcript: &str) -> Self

A plan that says “do not search”.

pub fn normalized(self) -> Self

Apply the §12.2 caps and drop empties, returning the trimmed plan.

Called on every plan regardless of origin, so a model that returns forty search terms produces a fast plan rather than a slow one.

pub fn cache_key(&self) -> String

A cache key covering everything that changes the result.

pub fn entity_forms(&self) -> Vec<String>

Every entity surface form the index should boost on.

Trait Implementations

impl Clone for RetrievalPlan

fn clone(&self) -> RetrievalPlan

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RetrievalPlan

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RetrievalPlan

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for RetrievalPlan

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 RetrievalPlan

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

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 RetrievalPlan