Struct SelfImprovementSystem 

pub struct SelfImprovementSystem { /* private fields */ }

Orchestrates the 4-phase self-improvement loop.

Example

let system = SelfImprovementSystem::new(config, storage, langbase);

// Record invocations (called after each tool use)
system.on_invocation(event).await;

// Check health and run cycle if needed
let health = system.check_health().await;
if health.should_act() {
    let result = system.run_cycle().await?;
}

Implementations

impl SelfImprovementSystem

pub fn new( config: SelfImprovementConfig, _storage: SqliteStorage, langbase: LangbaseClient, ) -> Self

Create a new self-improvement system.

Arguments

• config - System configuration
• storage - SQLite storage backend
• langbase - Langbase API client for pipe calls

Returns

A new SelfImprovementSystem instance.

pub fn is_enabled(&self) -> bool

Check if the system is enabled.

pub async fn on_invocation(&self, event: InvocationEvent)

Record an invocation for metric tracking.

This should be called after each tool invocation to feed the Monitor.

pub async fn check_health(&self) -> Option<HealthReport>

Get current health report from the Monitor.

Returns Some(HealthReport) if enough samples have been collected and it’s time for a check, None otherwise.

pub async fn force_health_check(&self) -> Option<HealthReport>

Force a health check regardless of timing.

pub async fn status(&self) -> SystemStatus

Get current system status.

pub async fn run_cycle(&self) -> Result<CycleResult, SelfImprovementError>

Run one improvement cycle (Monitor → Analyzer → Executor → Learner).

Returns

• Ok(CycleResult) - Cycle completed (may or may not have taken action)
• Err(SelfImprovementError) - Cycle blocked or failed

pub async fn force_cycle(&self) -> Result<CycleResult, SelfImprovementError>

Force run a cycle even if system would normally not act.

This bypasses health checks but still respects circuit breaker and rate limits.

pub async fn rollback( &self, action_id: &str, ) -> Result<(), SelfImprovementError>

Manually trigger a rollback of a previous action.

pub async fn pause(&self, duration: Duration)

Pause the system for a specified duration.

pub async fn resume(&self)

Resume the system from pause.