Struct SessionView 

pub struct SessionView { /* private fields */ }

A session-scoped, ephemeral semantic view over this conversation’s chain chunks (ADR-058 Phase 3.1).

Holds a per-session HNSW (so queries are structurally scoped) plus a manifest of chain_seq → [ChunkMeta]. Disposable: drop it at session end; rebuild it from the chain by re-inserting this session’s events.

Implementations

impl SessionView

pub fn for_embedder( session_id: impl Into<String>, embedder: &dyn EmbeddingProvider, ) -> Self

Create an empty session view sized to embedder’s output dimension (ADR-059 Qwen3 = 512; Mock fallback = its own dim). Preferred constructor so the index and the embedder can never disagree on width.

pub fn new(session_id: impl Into<String>, dims: usize) -> Self

Create an empty session view whose ephemeral index expects dims-wide vectors (use the embedder’s dimensions; ADR-059 Qwen3 = 512, Mock fallback = its own dim).

pub fn session_id(&self) -> &str

The conversation/session id this view is scoped to.

pub fn dims(&self) -> usize

Vector dimensionality of the ephemeral index.

pub fn len(&self) -> usize

Number of chunks indexed in this session view.

pub fn is_empty(&self) -> bool

true when no chunks have been indexed yet.

pub fn chain_seqs(&self) -> Vec<u64>

The chain sequences indexed in this view (the rebuild manifest).

pub fn chunk(&self, chain_seq: u64) -> Option<ChunkMeta>

Fetch a chunk’s metadata by chain sequence.

pub fn insert_vector(&self, vector: Vec<f32>, meta: ChunkMeta) -> bool

Insert a pre-embedded chunk into the ephemeral index, keyed by chain sequence. Low-level building block: 3.3 wraps this with the embedder and blob externalization. Replaces any existing chunk for the same chain_seq (idempotent re-graft / rebuild).

Returns false (and does not index) when vector does not match the view’s dimensionality — callers must embed with the configured model.

pub fn query(&self, query: &[f32], top_k: usize) -> Vec<ScopedHit>

Query the session-scoped index for the top_k nearest chunks.

Because the index holds only this session’s chunks, results are structurally scoped — a hit can only be from this conversation.

pub fn graft(&self, query: &[f32], top_k: usize) -> Vec<GraftedItem>

Graft the top_k most relevant chunks into the working set (ADR-058 Phase 3.2).

Scoped query → candidate branches → COW-reference graft: returns chain-sequence-keyed GraftedItems with provenance backrefs (chain_seq + content_hash) and a content reference (inline / blob / bare). Candidates are deduplicated by content hash — identical tool outputs or repeated file reads collapse to one item (the highest-scoring occurrence). The origin is never removed; this only references it.

pub async fn index_chunk( &self, embedder: &dyn EmbeddingProvider, store: Option<&ArtifactStore>, chain_seq: u64, kind: impl Into<String>, text: &str, inline_max: usize, ) -> Result<bool, EmbeddingError>

Embed and index one chain event into the session view (ADR-058 Phase 3.3).

Embeds text with the ADR-059 embedder (store f32; Qwen3 = @512) and indexes the vector keyed by chain_seq. When text exceeds inline_max bytes and an ArtifactStore is supplied, the full text is written as an RVF content-addressed blob and the chunk holds only the blob hash (no chain bloat, free dedup); otherwise the text rides inline. The chunk enters as NodeState::Frontier (live in the window).

Returns Ok(false) only if the embedder produced a vector whose width disagrees with the view (guarded against; use for_embedder).

pub async fn index_chunk_with_embed( &self, embedder: &dyn EmbeddingProvider, store: Option<&ArtifactStore>, chain_seq: u64, kind: impl Into<String>, text: &str, embed_input: &str, inline_max: usize, ) -> Result<bool, EmbeddingError>

Like index_chunk, but embeds embed_input while storing / hashing text (WEFT-640).

Used when the passage lane is a verbalized atom (text + classification + voice cues) but the grafted payload must remain the original turn text for the prompt. Content hash is over text so dedup stays content-stable across verbalizer format bumps.

pub async fn graft_text( &self, embedder: &dyn EmbeddingProvider, query_text: &str, top_k: usize, ) -> Result<Vec<GraftedItem>, EmbeddingError>

Convenience: embed a free-text query with embedder and graft the top_k nearest chunks (ADR-058 Phase 3.2 + 3.3, query side).

Uses EmbeddingProvider::embed_query (not plain embed) so asymmetric providers (e5 query: prefix, Qwen3 instruction) land queries in the correct half of the space (WEFT-640). Symmetric backends default embed_query → embed.

pub fn set_state(&self, chain_seq: u64, state: NodeState) -> bool

Set a chunk’s causal-model NodeState unconditionally. Returns false if the chunk is unknown. Prefer transition on the per-turn path so illegal lifecycle jumps are rejected.

pub fn state(&self, chain_seq: u64) -> Option<NodeState>

The current causal-model state of a chunk, if known.

pub fn set_speculative(&self, chain_seq: u64) -> bool

Mark a chunk NodeState::Speculative — above the wavefront, mutable, not yet hash-chained (ADR-062 D2). This is the per-turn entry state the kernel never assigned before P0.2. Returns false if unknown.

pub fn transition(&self, chain_seq: u64, next: NodeState) -> bool

Advance a chunk through a validated lifecycle transition (NodeState::can_transition_to, ADR-062 D2). Returns false if the chunk is unknown or the transition is illegal (the chunk is left unchanged in that case).

pub fn commit(&self, chain_seq: u64) -> bool

Commit a chunk to the durable trunk (NodeState::Committed) — the Frontier→Committed step fired at EOU (ADR-062 D5). Validated; returns false if unknown or not currently Frontier.

pub fn prune(&self, chain_seq: u64) -> bool

Prune a chunk from the live window (ADR-058 Phase 4.1).

Marks it NodeState::Stale but keeps it in the index — the origin stays on the chain and the chunk is re-graftable via retrieval. This is the application-level eviction that bounds L1 with no engine --context-shift. Returns false if the chunk is unknown.

pub fn regraft(&self, chain_seq: u64) -> bool

Re-graft a previously pruned chunk back into the live window (NodeState::Frontier). The chunk was never removed from the index, so this only flips its state. Returns false if unknown.

pub fn live_seqs(&self) -> Vec<u64>

Chain sequences currently live in the window (NodeState::Frontier), sorted ascending.

pub fn mark_important(&self, chain_seq: u64) -> bool

Mark a chunk “important to remember” — an explicit promotion signal (ADR-058 Phase 4.2, e.g. from a memory_store tool call). Returns false if the chunk is unknown.

pub fn is_important(&self, chain_seq: u64) -> bool

Whether a chunk was explicitly marked important.

pub fn ref_count(&self, chain_seq: u64) -> u32

How many times a chunk has been grafted/recalled (a promotion signal).