Struct SemanticQuery 

pub struct SemanticQuery {
    pub subject: String,
    pub purpose: Option<String>,
    pub text: String,
    pub embedding: Vec<f32>,
    pub index: IndexIdentity,
    pub limit: usize,
    pub max_sensitivity: Sensitivity,
    pub as_of: Timestamp,
}

A semantic query as the journal records it.

Assembled by the runtime from a SemanticSearch, the wired Embedder and the wired SemanticRetriever’s IndexIdentity. Every field is in the retrieval effect’s key, so a re-indexed corpus or a changed embedding revision is divergence a replay reports rather than a different answer nothing explains.

Fields

subject: String

purpose: Option<String>

text: String

The query as written — a search input, not only provenance.

It is carried beside the vector rather than derived from it because a retriever may legitimately want both: dense similarity for meaning and the literal terms for exact matches that embeddings famously lose — identifiers, error codes, product names. A retriever that fuses the two is doing hybrid retrieval, and everything it needs is already in this struct.

Where the fusion is declared is SemanticRetriever::profile, which is in the effect key: changing a weighting or switching fusion off is replay divergence rather than a silently different ranking. That is the supported axis, and it is per-retriever on purpose — a per-call knob would let one run rank two ways with nothing on the record saying which.

The shipped InMemorySemanticRetriever ignores this field and ranks on the vector alone. It is a reference implementation, not a statement about what the seam permits.

embedding: Vec<f32>

Exact query vector, obtained through StepCtx::embed.

It is in the retrieval effect’s key, so a replay must reproduce it exactly — which is why producing it is itself a journaled effect rather than a call a skill makes on its own. An embedding API is a network observation: two calls with the same text are not obliged to return the same floats, and a model revision guarantees they will not. Computing one inside the deterministic zone therefore quarantines a healthy run at the next replay, for a reason nothing on the record explains.

index: IndexIdentity

The space and snapshot this query was resolved against.

limit: usize

max_sensitivity: Sensitivity

Highest sensitivity this retriever may receive.

as_of: Timestamp

The lifecycle cutoff this selection was screened at.

A semantic index is derived and therefore stale by construction: it keeps naming versions after they are superseded, expire, or are erased. Live dispatch screens every hit against the authoritative store at this instant — the run’s journaled clock, so the cutoff is on the record beside the selection it shaped rather than being an ambient wall clock two machines disagree about.

Trait Implementations

impl Clone for SemanticQuery

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SemanticQuery

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SemanticQuery

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for SemanticQuery

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for SemanticQuery

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 SemanticQuery