Struct Session 

pub struct Session {
    pub loaded: BTreeMap<String, Record>,
    pub last_prompt: String,
    pub recent_prompts: Vec<String>,
    pub updated: u64,
}

Fields

loaded: BTreeMap<String, Record>

skill id -> how it got into context (and at what confidence).

last_prompt: String

The most recent user prompt in this conversation. Stashed by the hook only when telemetry is on, so a later self-load seen by ski observe (a recall miss — the model loaded a skill we never recommended) can be tied back to the prompt that was active. Empty otherwise; never serialized when empty, so the non-telemetry hot path leaves the file unchanged.

recent_prompts: Vec<String>

Recent user prompts in this conversation, oldest-first, bounded. Drives query-side context enrichment: a vague follow-up (“now do the other one”) is disambiguated by the turns that preceded it. Maintained only when the context feature is enabled (Config::context_depth > 0), so the default hot path neither writes nor carries it. #[serde(default)] + skip-when-empty keeps it invisible to indexes/sessions written before it existed.

updated: u64

Unix seconds of the last write (diagnostics only).

Implementations

impl Session

pub fn load(path: &Path) -> Session

Load state for a session, or an empty session if the file is missing or unreadable. Never errors.

pub fn save(&self, path: &Path) -> Result<()>

Persist state, stamping updated. Best-effort; callers in the hot path should ignore the result so state IO can’t block a prompt.

Writes a per-process temp file then atomically renames it over the target, so a concurrent reader (another hook/observe process sharing the session_id) never observes a half-written file — a torn read used to silently reset the session and re-arm dedup. The lost-update window — two writers racing the load→mutate→save and one dropping the other’s mark — remains; it costs at most a missed dedup (a re-injection), never corruption, and closing it would need an advisory lock.

pub fn is_loaded(&self, id: &str) -> bool

pub fn get(&self, id: &str) -> Option<&Record>

pub fn save_merged(&self, path: &Path) -> Result<()>

Persist like save, but first merge the loaded ledger with whatever is on disk now, so a mark written by a concurrent process survives. The hook loads its session snapshot, then spends the better part of a second embedding/reranking before saving — ample time for ski observe to record a model self-load that a plain save would overwrite (the lost mark re-arms dedup and the skill gets re-injected).

Merge rules, per skill id (dedup-safety errs toward suppression):

• present only on disk → kept (that’s the concurrent writer’s mark);
• Model beats Ski regardless of side (a used skill stays used);
• both Ski → the higher recorded confidence wins (matches should_recommend’s “no repeat after a HIGH showing”).

Prompt fields (last_prompt, recent_prompts) are taken from self: the hook is their only writer, and there is at most one hook per prompt. Callers that intentionally wipe state (the compaction re-arm) must use the plain save, or the merge would resurrect the ledger.

The load→rename window still exists but shrinks from the whole hook runtime to microseconds; closing it fully would need an advisory lock.

pub fn should_recommend(&self, id: &str, new_conf: f32, high: f32) -> bool

Whether id should be recommended now, at new_conf, given what we already know. The two dedup rules:

• a used skill (Source::Model) is never recommended again;
• a recommended-but-unused skill (Source::Ski) is re-recommended only when it newly reaches high confidence (it was shown below high before — a clearer prompt earns one stronger nudge; after a HIGH showing, never).

pub fn mark_recommended(&mut self, id: &str, confidence: f32)

Record that we recommended id at confidence. Stores the confidence we just showed (so the next-turn should_recommend test is accurate), but never downgrades a Model load — once the model used a skill it stays used.

pub fn mark_used(&mut self, id: &str)

Record that the model loaded id itself. Always wins (the strongest signal); keeps any confidence we’d previously shown for diagnostics.

pub fn mark(&mut self, id: &str, source: Source)

Generic mark, kept for callers/tests that don’t carry a confidence: Model via [mark_used], Ski as a confidence-0 first sighting that never overwrites an existing entry.

pub fn push_prompt(&mut self, prompt: &str, max: usize)

Append prompt to the rolling context window, keeping at most max of the most recent prompts (oldest dropped first). A blank prompt, or one identical to the immediately previous entry (a resubmit), is ignored so the window holds distinct conversational turns. max == 0 disables the window entirely (the feature-off path).

pub fn clear(&mut self)

Forget everything — used to re-arm on compaction so skills can be re-injected into the fresh summary.

Trait Implementations

impl Clone for Session

fn clone(&self) -> Session

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Session

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

Formats the value using the given formatter.

impl Default for Session

fn default() -> Session

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Session

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Session

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.