Struct Episode 

pub struct Episode {

    pub episode_id: Uuid,
    pub task_type: TaskType,
    pub task_description: String,
    pub context: TaskContext,
    pub start_time: DateTime<Utc>,
    pub end_time: Option<DateTime<Utc>>,
    pub steps: Vec<ExecutionStep>,
    pub outcome: Option<TaskOutcome>,
    pub reward: Option<RewardScore>,
    pub reflection: Option<Reflection>,
    pub patterns: Vec<PatternId>,
    pub heuristics: Vec<Uuid>,
    pub applied_patterns: Vec<PatternApplication>,
    pub salient_features: Option<SalientFeatures>,
    pub metadata: HashMap<String, String>,
    pub tags: Vec<String>,
    pub checkpoints: Vec<CheckpointMeta>,
}

Complete record of a task execution from start to finish.

Fields

episode_id: Uuid

Unique episode identifier

task_type: TaskType

Type of task

task_description: String

Description of the task

context: TaskContext

Task context and metadata

start_time: DateTime<Utc>

When episode started

end_time: Option<DateTime<Utc>>

When episode completed (None if in progress)

steps: Vec<ExecutionStep>

Execution steps

outcome: Option<TaskOutcome>

Final outcome

reward: Option<RewardScore>

Reward score

reflection: Option<Reflection>

Reflection on execution

patterns: Vec<PatternId>

Extracted pattern IDs

heuristics: Vec<Uuid>

Extracted heuristic IDs

applied_patterns: Vec<PatternApplication>

Record of patterns applied during execution

salient_features: Option<SalientFeatures>

Salient features extracted during pre-storage reasoning (PREMem)

metadata: HashMap<String, String>

Additional metadata

tags: Vec<String>

Tags for episode categorization (e.g., “bug-fix”, “feature”, “refactor”)

checkpoints: Vec<CheckpointMeta>

Checkpoints created during episode execution (ADR-044 Feature 3)

Implementations

impl Episode

pub fn new( task_description: String, context: TaskContext, task_type: TaskType, ) -> Self

Create a new episode for a task.

pub fn record_pattern_application( &mut self, pattern_id: PatternId, applied_at_step: usize, outcome: ApplicationOutcome, notes: Option<String>, )

Record that a pattern was applied during this episode

pub fn is_complete(&self) -> bool

Check if the episode has been completed.

pub fn duration(&self) -> Option<Duration>

Get the total duration of the episode.

pub fn add_step(&mut self, step: ExecutionStep)

Add a new execution step to this episode.

pub fn complete(&mut self, outcome: TaskOutcome)

Mark the episode as complete with a final outcome.

pub fn successful_steps_count(&self) -> usize

Count the number of successful execution steps.

pub fn failed_steps_count(&self) -> usize

Count the number of failed execution steps.

pub fn add_tag(&mut self, tag: String) -> Result<bool, String>

Add a tag to this episode (normalized, no duplicates) Returns Ok(true) if tag was added, Ok(false) if already exists, Err if invalid

pub fn remove_tag(&mut self, tag: &str) -> bool

Remove a tag from this episode Returns true if tag was removed, false if not found

pub fn has_tag(&self, tag: &str) -> bool

Check if episode has a specific tag

pub fn clear_tags(&mut self)

Clear all tags from this episode

pub fn get_tags(&self) -> &[String]

Get all tags for this episode

impl Episode

pub fn validate(&self) -> Result<(), String>

Validate that the episode has required fields.

pub fn validate_for_completion(&self) -> Result<(), String>

Validate that the episode is ready for completion.

pub fn summary(&self) -> String

Get a summary of the episode for logging purposes.

Trait Implementations

impl Clone for Episode

fn clone(&self) -> Episode

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 PartialEq for Episode

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