Struct Episode 

pub struct Episode {
    pub situation: String,
    pub tools: Vec<String>,
    pub outcome: String,
    pub tags: Vec<String>,
    pub skills: Vec<String>,
    pub success: Option<bool>,
}

One remembered experience.

Fields

situation: String

What the agent was asked / the situation it faced (the recall key).

tools: Vec<String>

Names of the tools called while handling it, in first-seen order.

outcome: String

How it turned out — the approach / final answer, summarized.

tags: Vec<String>

Extra retrieval tags (beyond the automatic ones).

skills: Vec<String>

Names of the skills the run followed, if any. Populated by the host (or by crate::experience::SkillUseTrace); the framework emits no skill-activation event of its own, so nothing fills this automatically.

This is the join key the reviser needs: “skill deploy-runbook was in play when this run went wrong”.

success: Option<bool>

Did the run achieve what it was asked to? None = the host never said.

Deliberately three-valued. Distillation treats “unknown” like “no”: a skill minted from a run nobody confirmed worked is exactly how bad procedural memory is born.

Implementations

impl Episode

pub fn new(situation: impl Into<String>, outcome: impl Into<String>) -> Self

pub fn with_tools<I, S>(self, tools: I) -> Self

where I: IntoIterator<Item = S>, S: Into<String>,

pub fn with_tags<I, S>(self, tags: I) -> Self

where I: IntoIterator<Item = S>, S: Into<String>,

pub fn with_skills<I, S>(self, skills: I) -> Self

where I: IntoIterator<Item = S>, S: Into<String>,

Names of the skills the run followed. See Episode::skills.

pub fn with_success(self, success: bool) -> Self

Whether the run achieved what it was asked to. See Episode::success.

pub fn succeeded(&self) -> bool

Convenience for the distiller’s gate: true only when the host explicitly said the run worked. Unknown counts as “no”.

pub fn render(&self) -> String

Natural-language rendering used as the searchable memory content. Keyword/semantic backends index this text; Episode::parse reverses it.

Skills used: / Result: are emitted only when set, and always before Outcome: — see the module docs for why that ordering is load-bearing.

pub fn parse(text: &str) -> Option<Episode>

Best-effort reconstruction from Episode::render output. Unknown / malformed text yields None.

Text written before skills/success existed parses fine: the two new prefixes simply aren’t found, and the fields come back empty/None.

Trait Implementations

impl Clone for Episode

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 Episode

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Episode

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Episode

impl PartialEq for Episode

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Episode

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 Episode