Struct StatePatch 

pub struct StatePatch {
    pub id: PatchId,
    pub title: String,
    pub summary: String,
    pub base_state_version: u64,
    pub base_project_ref: Option<ProjectRef>,
    pub ops: Vec<StateOp>,
    pub preconditions: Vec<Precondition>,
    pub expected_effects: Vec<ExpectedEffect>,
    pub evidence: Vec<NodeId>,
    pub artifacts: Vec<ArtifactRef>,
    pub status: PatchStatus,
    pub created_by: ActorRef,
}

Fields

id: PatchId

title: String

summary: String

base_state_version: u64

base_project_ref: Option<ProjectRef>

ops: Vec<StateOp>

preconditions: Vec<Precondition>

expected_effects: Vec<ExpectedEffect>

evidence: Vec<NodeId>

artifacts: Vec<ArtifactRef>

status: PatchStatus

created_by: ActorRef

Implementations

impl StatePatch

pub fn new( id: PatchId, title: impl Into<String>, summary: impl Into<String>, created_by: ActorRef, ) -> Self

Examples found in repository

examples/patch_eval_decision.rs (lines 23-28)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let state = YoAgentState::load(MemoryEventStore::new()).await?;
    let actor = ActorRef::agent("yoyo-evolve");

    let failure = NodeId::new("failure_17");
    state
        .record_failure(
            actor.clone(),
            failure.clone(),
            "tool_retry_survives_timeout fails",
            "Retry state is lost when timeout cancels the future.",
        )
        .await?;

    let patch_id = PatchId::new("patch_42");
    let mut patch = StatePatch::new(
        patch_id.clone(),
        "Persist retry state across timeout",
        "Add RetryState and keep attempt count outside the cancelled future.",
        actor.clone(),
    );
    patch.evidence.push(failure);
    patch.preconditions.push(Precondition::TestStillFailing {
        name: "tool_retry_survives_timeout".to_string(),
    });
    patch.expected_effects.push(ExpectedEffect::TestPasses {
        name: "tool_retry_survives_timeout".to_string(),
    });
    patch.artifacts.push(
        ArtifactRef::new("git.diff", "file://.yoyo/artifacts/patch_42.diff")
            .with_summary("Fix retry persistence and add timeout regression test")
            .with_metadata(json!({
                "base_commit": "abc123",
                "files_changed": [
                    "crates/yoagent-runtime/src/tool.rs",
                    "crates/yoagent-runtime/tests/retry.rs"
                ]
            })),
    );

    state.propose_patch(patch).await?;
    state
        .record_eval_result(
            actor,
            NodeId::new("eval_55"),
            patch_id.clone(),
            "cargo test tool_retry_survives_timeout",
            true,
        )
        .await?;
    state
        .record_decision(
            ActorRef::user("yuanhao"),
            NodeId::new("decision_9"),
            patch_id.clone(),
            true,
            "Eval passed; approve promotion",
        )
        .await?;
    state
        .update_patch_status(
            patch_id.clone(),
            PatchStatus::Approved,
            Some("Eval passed".to_string()),
        )
        .await?;
    state
        .update_patch_status(
            patch_id.clone(),
            PatchStatus::Promoted,
            Some("Promoted as commit def456".to_string()),
        )
        .await?;

    print!(
        "{}",
        state.lineage(NodeId::new(patch_id.0)).await.to_markdown()
    );
    Ok(())
}

examples/yoyo_evolve_demo.rs (lines 26-31)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let state = YoAgentState::load(yoagent_state::MemoryEventStore::new()).await?;
    let actor = ActorRef::agent("yoyo-evolve");

    let failure = NodeId::new("failure_retry_timeout");
    state
        .record_failure(
            actor.clone(),
            failure.clone(),
            "Retry eval fails after timeout",
            "The retry attempt count is reset when the timeout cancels the future.",
        )
        .await?;

    let changed = parse_git_name_status(
        "M crates/yoagent-runtime/src/tool.rs\nA crates/yoagent-runtime/tests/retry.rs\n",
    );
    let patch_id = PatchId::new("patch_retry_timeout");
    let mut patch = StatePatch::new(
        patch_id.clone(),
        "Persist retry state across timeout",
        "Move attempt count into RetryState and keep it outside the cancelled future.",
        actor.clone(),
    );
    patch.base_project_ref = Some(project_ref(
        "yoagent",
        Some("main".to_string()),
        Some("abc123".to_string()),
        None,
    ));
    patch.evidence.push(failure);
    patch
        .preconditions
        .push(Precondition::ProjectCommitIs("abc123".to_string()));
    patch.expected_effects.push(ExpectedEffect::TestPasses {
        name: "tool_retry_survives_timeout".to_string(),
    });
    patch.artifacts.push(diff_artifact(
        ".yoyo/artifacts/patch_retry_timeout.diff",
        "Persist retry state and add timeout regression test",
        "abc123",
        &changed,
    ));
    patch
        .ops
        .extend(changed_file_ops(patch_id.clone(), &changed));

    state.propose_patch(patch).await?;
    state
        .record_eval_result(
            actor,
            NodeId::new("eval_retry_timeout"),
            patch_id.clone(),
            "cargo test tool_retry_survives_timeout",
            true,
        )
        .await?;
    state
        .record_decision(
            ActorRef::user("yuanhao"),
            NodeId::new("decision_promote_retry_timeout"),
            patch_id.clone(),
            true,
            "Regression test passed",
        )
        .await?;
    state
        .update_patch_status(
            patch_id.clone(),
            PatchStatus::Promoted,
            Some("Promoted as commit def456".to_string()),
        )
        .await?;

    let lineage = state.lineage(NodeId::new(patch_id.0)).await;
    println!("{}", lineage.to_markdown());
    println!(
        "changed_files={}",
        json!(changed.iter().map(|file| &file.path).collect::<Vec<_>>())
    );
    Ok(())
}

examples/goal_lineage.rs (lines 53-58)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let actor = ActorRef::agent("yoyo-evolve");
    let state = YoAgentState::load(MemoryEventStore::new()).await?;

    let goal = Goal {
        status: GoalStatus::InProgress,
        ..Goal::new(
            GoalId::new("goal_retry_reliability"),
            "Make retry behavior reliable",
            "Retry attempts should survive timeout cancellation.",
            actor.clone(),
        )
    };
    state.record_goal(goal).await?;

    let task = Task {
        id: TaskId::new("task_retry_timeout"),
        title: "Fix timeout retry state".to_string(),
        summary: "Investigate and patch retry state loss.".to_string(),
        status: TaskStatus::InProgress,
        goal: Some(GoalId::new("goal_retry_reliability")),
        created_by: actor.clone(),
        metadata: json!({}),
    };
    state.record_task(task).await?;

    let failure = NodeId::new("failure_retry_timeout");
    state
        .record_failure(
            actor.clone(),
            failure.clone(),
            "retry timeout loses state",
            "The next attempt starts from zero after cancellation.",
        )
        .await?;
    state
        .link(
            actor.clone(),
            failure.clone(),
            yoagent_state::REL_BLOCKS,
            NodeId::new("goal_retry_reliability"),
        )
        .await?;

    let patch_id = PatchId::new("patch_retry_state");
    let mut patch = StatePatch::new(
        patch_id.clone(),
        "Persist retry state",
        "Keep attempt count outside the cancelled future.",
        actor.clone(),
    );
    patch.evidence.push(failure);
    patch.expected_effects.push(ExpectedEffect::TestPasses {
        name: "tool_retry_survives_timeout".to_string(),
    });
    patch.artifacts.push(ArtifactRef::new(
        "git.diff",
        "file://.yoyo/artifacts/patch_retry_state.diff",
    ));
    state.propose_patch(patch).await?;
    state
        .link(
            actor.clone(),
            NodeId::new(patch_id.0.clone()),
            yoagent_state::REL_ADVANCES,
            NodeId::new("goal_retry_reliability"),
        )
        .await?;
    state
        .record_eval_result(
            actor,
            NodeId::new("eval_retry_timeout"),
            patch_id.clone(),
            "cargo test tool_retry_survives_timeout",
            true,
        )
        .await?;
    state
        .update_patch_status(
            patch_id,
            PatchStatus::Promoted,
            Some("eval passed".to_string()),
        )
        .await?;

    print!(
        "{}",
        state
            .lineage(NodeId::new("goal_retry_reliability"))
            .await
            .to_markdown()
    );
    Ok(())
}

Trait Implementations

impl Clone for StatePatch

fn clone(&self) -> StatePatch

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for StatePatch

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for StatePatch

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for StatePatch

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

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 StatePatch