Struct PCPRuntime 

pub struct PCPRuntime {
    pub(crate) config: PCPConfig,
    pub(crate) checkpoints: Vec<PCPCheckpoint>,
}

PCP Runtime - the main validation and checkpoint engine.

Fields

config: PCPConfig

PCP configuration

checkpoints: Vec<PCPCheckpoint>

Checkpoints stored in memory (in production, backed by storage)

Implementations

impl PCPRuntime

pub fn new(config: PCPConfig) -> CellstateResult<Self>

Create a new PCP runtime with the given configuration.

pub fn config(&self) -> &PCPConfig

Get the configuration.

impl PCPRuntime

pub fn validate_context_integrity( &self, scope: &Scope, artifacts: &[Artifact], current_tokens: i32, ) -> CellstateResult<ValidationResult>

Validate context integrity. Checks for stale data, missing references, and dosage limits.

Arguments

• scope - The scope to validate
• artifacts - Artifacts in the scope
• current_tokens - Current token count in the scope

Returns

ValidationResult with any issues found

pub(crate) fn check_dosage_limits( &self, result: &mut ValidationResult, artifact_count: i32, token_count: i32, )

Check dosage limits.

pub(crate) fn check_stale_scope( &self, result: &mut ValidationResult, scope: &Scope, )

Check if scope is stale.

pub(crate) fn check_artifact_integrity( &self, result: &mut ValidationResult, artifact: &Artifact, )

Check artifact integrity.

impl PCPRuntime

pub fn detect_contradictions( &self, artifacts: &[Artifact], ) -> CellstateResult<Vec<Contradiction>>

Detect contradictions between artifacts using embedding similarity. Two artifacts are considered potentially contradictory if:

1. They have high embedding similarity (similar topic)
2. Their content differs significantly

Arguments

• artifacts - Artifacts to check for contradictions

Returns

Vector of detected contradictions

impl PCPRuntime

pub fn apply_dosage_limits( &self, artifacts: &[Artifact], current_tokens: i32, ) -> CellstateResult<DosageResult>

Apply dosage limits to artifacts and tokens. Returns which artifacts should be pruned to stay within limits.

Arguments

• artifacts - Current artifacts (sorted by priority/recency)
• current_tokens - Current token count

Returns

DosageResult indicating what needs to be pruned

pub fn would_exceed_limits( &self, current_artifacts: i32, current_tokens: i32, additional_artifacts: i32, additional_tokens: i32, ) -> bool

Check if adding more content would exceed dosage limits.

Arguments

• current_artifacts - Current artifact count
• current_tokens - Current token count
• additional_artifacts - Artifacts to add
• additional_tokens - Tokens to add

Returns

true if adding would exceed limits

impl PCPRuntime

pub fn lint_artifact( &self, artifact: &Artifact, existing_artifacts: &[Artifact], ) -> CellstateResult<LintResult>

Lint an artifact for quality issues. Checks for size, duplicates, missing embeddings, and low confidence.

Arguments

• artifact - The artifact to lint
• existing_artifacts - Existing artifacts to check for duplicates

Returns

LintResult with any issues found

pub(crate) fn check_artifact_size( &self, result: &mut LintResult, artifact: &Artifact, )

Check if artifact content is too large.

pub(crate) fn check_artifact_duplicates( &self, result: &mut LintResult, artifact: &Artifact, existing_artifacts: &[Artifact], )

Check for duplicate artifacts by content hash.

pub(crate) fn check_artifact_embedding( &self, result: &mut LintResult, artifact: &Artifact, )

Check if artifact is missing embedding.

pub(crate) fn check_artifact_confidence( &self, result: &mut LintResult, artifact: &Artifact, )

Check artifact confidence score.

pub(crate) fn check_artifact_semantics( &self, result: &mut LintResult, artifact: &Artifact, )

Check semantic markdown/context hazards inside artifact content.

pub fn lint_artifacts( &self, artifacts: &[Artifact], ) -> CellstateResult<LintResult>

Lint multiple artifacts at once.

Arguments

• artifacts - Artifacts to lint

Returns

Combined LintResult for all artifacts

impl PCPRuntime

pub fn create_checkpoint( &mut self, scope: &Scope, artifacts: &[Artifact], note_ids: &[NoteId], ) -> CellstateResult<PCPCheckpoint>

Create a checkpoint for a scope. Captures the current state for potential recovery.

Arguments

• scope - The scope to checkpoint
• artifacts - Current artifacts in the scope
• note_ids - Current note IDs referenced by the scope

Returns

The created checkpoint

pub(crate) fn enforce_checkpoint_limit(&mut self)

Enforce the maximum checkpoint limit by removing oldest checkpoints.

pub fn recover_from_checkpoint( &self, checkpoint: &PCPCheckpoint, ) -> CellstateResult<RecoveryResult>

Recover a scope from a checkpoint.

Arguments

• checkpoint - The checkpoint to recover from

Returns

RecoveryResult with the recovered scope

pub fn get_latest_checkpoint(&self, scope_id: ScopeId) -> Option<&PCPCheckpoint>

Get the latest checkpoint for a scope.

Arguments

• scope_id - The scope to get checkpoint for

Returns

The latest checkpoint if found

pub fn get_checkpoints_for_scope( &self, scope_id: ScopeId, ) -> Vec<&PCPCheckpoint>

Get all checkpoints for a scope.

Arguments

• scope_id - The scope to get checkpoints for

Returns

Vector of checkpoints for the scope

pub fn delete_checkpoint(&mut self, checkpoint_id: Uuid) -> bool

Delete a checkpoint.

Arguments

• checkpoint_id - The checkpoint to delete

Returns

true if checkpoint was deleted

pub fn clear_checkpoints_for_scope(&mut self, scope_id: ScopeId) -> usize

Clear all checkpoints for a scope.

Arguments

• scope_id - The scope to clear checkpoints for

Returns

Number of checkpoints deleted

impl PCPRuntime

pub fn check_summarization_triggers( &self, scope: &Scope, turn_count: i32, artifact_count: i32, policies: &[SummarizationPolicy], ) -> CellstateResult<Vec<(SummarizationPolicyId, SummarizationTrigger)>>

Check which summarization triggers should fire based on current scope state.

This method evaluates all provided summarization policies against the current state of a scope and returns which triggers should activate. Inspired by EVOLVE-MEM’s self-improvement engine.

Arguments

• scope - The scope to evaluate triggers for
• turn_count - Number of turns in the scope
• artifact_count - Number of artifacts in the scope
• policies - Summarization policies to check

Returns

Vector of (summarization_policy_id, triggered_trigger) pairs for policies that should fire

Example

let triggered = runtime.check_summarization_triggers(
    &scope,
    turns.len() as i32,
    artifacts.len() as i32,
    &policies,
)?;

for (summarization_policy_id, trigger) in triggered {
    // Execute summarization for this policy
}

pub fn get_abstraction_transition( &self, policy: &SummarizationPolicy, ) -> (AbstractionLevel, AbstractionLevel)

Calculate what abstraction level transition should occur for a policy.

Arguments

• policy - The policy defining source->target transition

Returns

Tuple of (source_level, target_level) for the summarization operation

pub fn validate_abstraction_transition( &self, source: AbstractionLevel, target: AbstractionLevel, ) -> bool

Validate an abstraction level transition.

Valid transitions are:

• Raw -> Summary (L0 -> L1)
• Summary -> Principle (L1 -> L2)
• Raw -> Principle (L0 -> L2, skipping L1)

Invalid transitions:

• Summary -> Raw (downgrade)
• Principle -> Summary/Raw (downgrade)
• Same level to same level

Arguments

• source - Source abstraction level
• target - Target abstraction level

Returns

true if the transition is valid

Trait Implementations

impl Clone for PCPRuntime

fn clone(&self) -> PCPRuntime

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PCPRuntime

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

Formats the value using the given formatter.