Struct GepCapsule 

pub struct GepCapsule {

    pub capsule_type: String,
    pub schema_version: String,
    pub id: String,
    pub trigger: Vec<String>,
    pub gene: String,
    pub summary: String,
    pub content: Option<CapsuleContent>,
    pub diff: Option<String>,
    pub strategy: Option<Vec<String>>,
    pub confidence: f32,
    pub blast_radius: BlastRadius,
    pub outcome: CapsuleOutcome,
    pub success_streak: Option<u32>,
    pub env_fingerprint: Option<EnvFingerprint>,
    pub model_name: Option<String>,
    pub asset_id: String,
    pub trigger_context: Option<TriggerContext>,
    pub reused_asset_id: Option<String>,
    pub source_type: CapsuleSourceType,
}

GEP-compatible Capsule definition

Fields

capsule_type: String

Asset type - always “Capsule”

schema_version: String

Protocol schema version

id: String

Unique identifier (e.g., capsule_1708123456789)

trigger: Vec<String>

Signals that triggered this evolution

gene: String

ID of the gene used

summary: String

Human-readable description

content: Option<CapsuleContent>

Structured description

diff: Option<String>

Git diff of actual code changes

strategy: Option<Vec<String>>

Ordered execution steps

confidence: f32

Confidence 0.0-1.0

blast_radius: BlastRadius

Blast radius

outcome: CapsuleOutcome

Outcome

success_streak: Option<u32>

Consecutive successes with this gene

env_fingerprint: Option<EnvFingerprint>

Runtime environment snapshot

model_name: Option<String>

LLM model that produced this capsule

asset_id: String

Content-addressable hash

trigger_context: Option<TriggerContext>

Trigger context (optional)

reused_asset_id: Option<String>

ID of reused capsule (if reused)

source_type: CapsuleSourceType

Source type: generated, reused, or reference

Implementations

impl GepCapsule

pub fn new( id: String, trigger: Vec<String>, gene: String, summary: String, diff: String, confidence: f32, ) -> Result<Self, AssetIdError>

Create a new GEP Capsule with computed asset_id

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

Validate the capsule has minimum substance

pub fn with_content(self, content: CapsuleContent) -> Self

Set the content

pub fn with_strategy(self, strategy: Vec<String>) -> Self

Set the strategy

pub fn with_blast_radius(self, files: usize, lines: usize) -> Self

Set the blast radius

pub fn with_trigger_context(self, ctx: TriggerContext) -> Self

Set the trigger context

pub fn as_reused(self, reused_id: String) -> Self

Mark as reused capsule

Trait Implementations

impl Clone for GepCapsule

fn clone(&self) -> GepCapsule

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for GepCapsule

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for GepCapsule

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<&Capsule> for GepCapsule

Convert from Oris core Capsule to GEP Capsule

fn from(oris_capsule: &Capsule) -> Self

Converts to this type from the input type.

impl Serialize for GepCapsule

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

where __S: Serializer,

Serialize this value into the given Serde serializer.