Enum ExperienceType 

pub enum ExperienceType {
    Difficulty {
        description: String,
        severity: Severity,
    },
    Solution {
        problem_ref: Option<ExperienceId>,
        approach: String,
        worked: bool,
    },
    ErrorPattern {
        signature: String,
        fix: String,
        prevention: String,
    },
    SuccessPattern {
        task_type: String,
        approach: String,
        quality: f32,
    },
    UserPreference {
        category: String,
        preference: String,
        strength: f32,
    },
    ArchitecturalDecision {
        decision: String,
        rationale: String,
    },
    TechInsight {
        technology: String,
        insight: String,
    },
    Fact {
        statement: String,
        source: String,
    },
    Generic {
        category: Option<String>,
    },
}

Rich experience type with associated data per variant.

This is the full type stored in the experience record. For index keys, use type_tag() to get the compact ExperienceTypeTag discriminant.

Variants

Each variant carries structured data specific to that kind of experience:

• Difficulty — A problem the agent encountered
• Solution — A fix for a problem, optionally linked to a Difficulty
• ErrorPattern — A reusable error signature with fix and prevention
• SuccessPattern — A proven approach with quality rating
• UserPreference — A user preference with strength
• ArchitecturalDecision — A design decision with rationale
• TechInsight — Technical knowledge about a technology
• Fact — A verified factual statement with source
• Generic — Catch-all for uncategorized experiences

Variants

Difficulty

Problem encountered by the agent.

Fields

description: String

What the problem is.

severity: Severity

How severe the problem is.

Solution

Fix for a problem, optionally linked to a Difficulty experience.

Fields

problem_ref: Option<ExperienceId>

Reference to the Difficulty experience this solves, if any.

approach: String

The approach taken to solve the problem.

worked: bool

Whether the solution worked.

ErrorPattern

Reusable error signature with fix and prevention strategy.

Fields

signature: String

The error signature (e.g., error code, message pattern).

fix: String

How to fix occurrences of this error.

prevention: String

How to prevent this error from occurring.

SuccessPattern

Proven approach with quality rating (0.0–1.0).

Fields

task_type: String

The type of task this pattern applies to.

approach: String

The approach that works.

quality: f32

Quality rating of the outcome (0.0–1.0).

UserPreference

User preference with strength (0.0–1.0).

Fields

category: String

The preference category (e.g., “style”, “tooling”).

preference: String

The specific preference.

strength: f32

How strongly the user feels about this (0.0–1.0).

ArchitecturalDecision

Design decision with rationale.

Fields

decision: String

The decision made.

rationale: String

Why this decision was made.

TechInsight

Technical knowledge about a specific technology.

Fields

technology: String

The technology this insight is about.

insight: String

The insight or knowledge.

Fact

Verified factual statement with source attribution.

Fields

statement: String

The factual statement.

source: String

Where this fact was verified.

Generic

Catch-all for uncategorized experiences.

Fields

category: Option<String>

Optional category label.

Implementations

impl ExperienceType

pub fn type_tag(&self) -> ExperienceTypeTag

Returns the compact ExperienceTypeTag for use in index keys.

This bridges the rich type (with data) to the 1-byte discriminant stored in secondary index keys.

Trait Implementations

impl Clone for ExperienceType

fn clone(&self) -> ExperienceType

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ExperienceType

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

Formats the value using the given formatter.

impl Default for ExperienceType

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ExperienceType

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for ExperienceType

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

where __S: Serializer,

Serialize this value into the given Serde serializer.