Struct YoAgentState 

pub struct YoAgentState<S: EventStore> { /* private fields */ }

Implementations

impl<S: EventStore> YoAgentState<S>

pub async fn load(store: S) -> Result<Self, StateError>

Examples found in repository

examples/policy_approval.rs (line 9)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let state = YoAgentState::load(MemoryEventStore::new()).await?;
    let mut runtime = YoAgentRuntime::new(state.clone());
    runtime.register_policy(Policy::require_approval(
        PolicyId::new("policy_create_node_review"),
        "Creating graph nodes requires review",
        PolicyAction::CreateNode,
    ));

    let result = runtime
        .create_typed_node(
            ActorRef::agent("demo"),
            NodeId::new("sensitive_node"),
            "memory",
            json!({ "title": "Potentially sensitive memory" }),
        )
        .await;

    match result {
        Err(StateError::PolicyDenied(message)) => println!("blocked: {message}"),
        other => println!("unexpected: {other:?}"),
    }

    let approvals = state
        .graph()
        .await
        .nodes
        .values()
        .filter(|node| node.kind == "approval_request")
        .count();
    println!("approval_requests={approvals}");
    Ok(())
}

examples/replay_and_fork.rs (line 8)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let state = YoAgentState::load(MemoryEventStore::new()).await?;
    let first = state
        .apply_ops(
            ActorRef::agent("demo"),
            vec![StateOp::CreateNode {
                id: NodeId::new("goal_1"),
                kind: "goal".to_string(),
                props: json!({ "title": "Improve retry reliability" }),
            }],
        )
        .await?;
    state
        .apply_ops(
            ActorRef::agent("demo"),
            vec![StateOp::CreateNode {
                id: NodeId::new("task_1"),
                kind: "task".to_string(),
                props: json!({ "title": "Investigate timeout" }),
            }],
        )
        .await?;

    let fork = state
        .fork_at_event(ForkId::new("fork_before_task"), Some(first))
        .await?;
    let diff = diff_graphs(&fork.graph, &state.graph().await);
    println!("fork_nodes={}", fork.graph.nodes.len());
    println!("current_nodes={}", state.graph().await.nodes.len());
    println!("added_nodes={:?}", diff.added_nodes);
    Ok(())
}

examples/typed_pack.rs (line 9)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let state = YoAgentState::load(MemoryEventStore::new()).await?;
    let mut runtime = YoAgentRuntime::new(state.clone());
    runtime.register_pack(
        Pack::new(PackId::new("pack_lineage"), "lineage", "0.1.0")
            .add_object_type(ObjectType::new("goal").require("title"))
            .add_object_type(ObjectType::new("task").require("title"))
            .add_relation_type(
                RelationType::new("serves")
                    .from_kind("task")
                    .to_kind("goal"),
            ),
    );

    runtime
        .create_typed_node(
            ActorRef::agent("demo"),
            NodeId::new("goal_1"),
            "goal",
            json!({ "title": "Improve retry reliability" }),
        )
        .await?;
    runtime
        .create_typed_node(
            ActorRef::agent("demo"),
            NodeId::new("task_1"),
            "task",
            json!({ "title": "Investigate timeout" }),
        )
        .await?;
    runtime
        .create_typed_relation(
            ActorRef::agent("demo"),
            NodeId::new("task_1"),
            "serves",
            NodeId::new("goal_1"),
            json!({}),
        )
        .await?;

    println!("{}", serde_json::to_string_pretty(&state.graph().await)?);
    Ok(())
}

examples/behavior_subscription.rs (line 9)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let state = YoAgentState::load(MemoryEventStore::new()).await?;
    let mut runtime = YoAgentRuntime::new(state.clone());

    runtime.register_behavior(FnBehavior::new(
        BehaviorId::new("behavior_failure_to_task"),
        EventPattern::Kind("failure.observed".to_string()),
        |_ctx: BehaviorContext, event: Event| async move {
            let title = event
                .payload
                .get("title")
                .and_then(|value| value.as_str())
                .unwrap_or("Investigate failure");
            Ok(vec![StateOp::CreateNode {
                id: NodeId::new("task_from_failure"),
                kind: "task".to_string(),
                props: json!({
                    "title": format!("Investigate: {title}"),
                    "status": "Open",
                    "created_by_behavior": "behavior_failure_to_task",
                }),
            }])
        },
    ));

    runtime
        .emit_event(Event::new(
            ActorRef::agent("demo"),
            "failure.observed",
            json!({ "title": "retry timeout loses state" }),
        ))
        .await?;

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

examples/basic_lineage.rs (line 6)

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

    let failure = NodeId::new("failure_retry_timeout");
    let hypothesis = NodeId::new("hypothesis_retry_state_lost");

    state
        .apply_ops(
            actor,
            vec![
                StateOp::CreateNode {
                    id: failure.clone(),
                    kind: "failure".to_string(),
                    props: json!({
                        "title": "Retry state is lost after timeout",
                        "summary": "The next retry starts from attempt zero."
                    }),
                },
                StateOp::CreateNode {
                    id: hypothesis.clone(),
                    kind: "hypothesis".to_string(),
                    props: json!({
                        "title": "Attempt count is scoped to the cancelled future"
                    }),
                },
                StateOp::CreateRelation {
                    from: hypothesis.clone(),
                    rel: "explains".to_string(),
                    to: failure,
                    props: json!({}),
                },
            ],
        )
        .await?;

    print!("{}", state.lineage(hypothesis).await.to_markdown());
    Ok(())
}

examples/yoagent_integration.rs (line 10)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let state = YoAgentState::load(MemoryEventStore::new()).await?;
    let sink = YoAgentStateAdapter::new(state.clone(), ActorRef::agent("yoagent"));
    let run_id = RunId::new("run_demo");

    sink.on_run_started(YoAgentRunStarted {
        run_id: run_id.clone(),
        task: "Investigate retry timeout".to_string(),
        metadata: json!({}),
    })
    .await?;
    sink.on_model_called(YoAgentModelCalled {
        run_id: run_id.clone(),
        model: "example-model".to_string(),
        prompt_summary: "Find likely retry failure cause".to_string(),
    })
    .await?;
    sink.on_model_finished(YoAgentModelFinished {
        run_id: run_id.clone(),
        model: "example-model".to_string(),
        output_summary: "Retry state appears scoped too narrowly".to_string(),
    })
    .await?;
    sink.on_tool_called(YoAgentToolCalled {
        run_id: run_id.clone(),
        tool: "cargo test".to_string(),
        input_summary: "tool_retry_survives_timeout".to_string(),
    })
    .await?;
    sink.on_tool_finished(YoAgentToolFinished {
        run_id: run_id.clone(),
        tool: "cargo test".to_string(),
        output_summary: "test passed".to_string(),
        success: true,
    })
    .await?;
    sink.on_run_finished(YoAgentRunFinished {
        run_id,
        outcome: "patch ready for review".to_string(),
        metadata: json!({}),
    })
    .await?;

    println!(
        "{}",
        serde_json::to_string_pretty(&state.store().scan().await?)?
    );
    Ok(())
}

Additional examples can be found in:

• examples/patch_eval_decision.rs
• examples/yoyo_evolve_demo.rs
• examples/goal_lineage.rs

pub fn store(&self) -> Arc<S>

Examples found in repository

examples/yoagent_integration.rs (line 54)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let state = YoAgentState::load(MemoryEventStore::new()).await?;
    let sink = YoAgentStateAdapter::new(state.clone(), ActorRef::agent("yoagent"));
    let run_id = RunId::new("run_demo");

    sink.on_run_started(YoAgentRunStarted {
        run_id: run_id.clone(),
        task: "Investigate retry timeout".to_string(),
        metadata: json!({}),
    })
    .await?;
    sink.on_model_called(YoAgentModelCalled {
        run_id: run_id.clone(),
        model: "example-model".to_string(),
        prompt_summary: "Find likely retry failure cause".to_string(),
    })
    .await?;
    sink.on_model_finished(YoAgentModelFinished {
        run_id: run_id.clone(),
        model: "example-model".to_string(),
        output_summary: "Retry state appears scoped too narrowly".to_string(),
    })
    .await?;
    sink.on_tool_called(YoAgentToolCalled {
        run_id: run_id.clone(),
        tool: "cargo test".to_string(),
        input_summary: "tool_retry_survives_timeout".to_string(),
    })
    .await?;
    sink.on_tool_finished(YoAgentToolFinished {
        run_id: run_id.clone(),
        tool: "cargo test".to_string(),
        output_summary: "test passed".to_string(),
        success: true,
    })
    .await?;
    sink.on_run_finished(YoAgentRunFinished {
        run_id,
        outcome: "patch ready for review".to_string(),
        metadata: json!({}),
    })
    .await?;

    println!(
        "{}",
        serde_json::to_string_pretty(&state.store().scan().await?)?
    );
    Ok(())
}

pub async fn record_event(&self, event: Event) -> Result<EventId, StateError>

pub async fn apply_ops( &self, actor: ActorRef, ops: Vec<StateOp>, ) -> Result<EventId, StateError>

Examples found in repository

examples/replay_and_fork.rs (lines 10-17)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let state = YoAgentState::load(MemoryEventStore::new()).await?;
    let first = state
        .apply_ops(
            ActorRef::agent("demo"),
            vec![StateOp::CreateNode {
                id: NodeId::new("goal_1"),
                kind: "goal".to_string(),
                props: json!({ "title": "Improve retry reliability" }),
            }],
        )
        .await?;
    state
        .apply_ops(
            ActorRef::agent("demo"),
            vec![StateOp::CreateNode {
                id: NodeId::new("task_1"),
                kind: "task".to_string(),
                props: json!({ "title": "Investigate timeout" }),
            }],
        )
        .await?;

    let fork = state
        .fork_at_event(ForkId::new("fork_before_task"), Some(first))
        .await?;
    let diff = diff_graphs(&fork.graph, &state.graph().await);
    println!("fork_nodes={}", fork.graph.nodes.len());
    println!("current_nodes={}", state.graph().await.nodes.len());
    println!("added_nodes={:?}", diff.added_nodes);
    Ok(())
}

examples/basic_lineage.rs (lines 13-38)

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

    let failure = NodeId::new("failure_retry_timeout");
    let hypothesis = NodeId::new("hypothesis_retry_state_lost");

    state
        .apply_ops(
            actor,
            vec![
                StateOp::CreateNode {
                    id: failure.clone(),
                    kind: "failure".to_string(),
                    props: json!({
                        "title": "Retry state is lost after timeout",
                        "summary": "The next retry starts from attempt zero."
                    }),
                },
                StateOp::CreateNode {
                    id: hypothesis.clone(),
                    kind: "hypothesis".to_string(),
                    props: json!({
                        "title": "Attempt count is scoped to the cancelled future"
                    }),
                },
                StateOp::CreateRelation {
                    from: hypothesis.clone(),
                    rel: "explains".to_string(),
                    to: failure,
                    props: json!({}),
                },
            ],
        )
        .await?;

    print!("{}", state.lineage(hypothesis).await.to_markdown());
    Ok(())
}

pub async fn propose_patch( &self, patch: StatePatch, ) -> Result<PatchId, StateError>

Examples found in repository

examples/patch_eval_decision.rs (line 48)

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 (line 55)

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 (line 67)

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(())
}

pub async fn update_patch_status( &self, patch_id: PatchId, status: PatchStatus, reason: Option<String>, ) -> Result<EventId, StateError>

Examples found in repository

examples/patch_eval_decision.rs (lines 68-72)

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 75-79)

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 86-90)

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(())
}

pub async fn attach_artifact( &self, node_id: NodeId, artifact: ArtifactRef, ) -> Result<EventId, StateError>

pub async fn graph(&self) -> GraphSnapshot

Examples found in repository

examples/policy_approval.rs (line 32)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let state = YoAgentState::load(MemoryEventStore::new()).await?;
    let mut runtime = YoAgentRuntime::new(state.clone());
    runtime.register_policy(Policy::require_approval(
        PolicyId::new("policy_create_node_review"),
        "Creating graph nodes requires review",
        PolicyAction::CreateNode,
    ));

    let result = runtime
        .create_typed_node(
            ActorRef::agent("demo"),
            NodeId::new("sensitive_node"),
            "memory",
            json!({ "title": "Potentially sensitive memory" }),
        )
        .await;

    match result {
        Err(StateError::PolicyDenied(message)) => println!("blocked: {message}"),
        other => println!("unexpected: {other:?}"),
    }

    let approvals = state
        .graph()
        .await
        .nodes
        .values()
        .filter(|node| node.kind == "approval_request")
        .count();
    println!("approval_requests={approvals}");
    Ok(())
}

examples/replay_and_fork.rs (line 33)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let state = YoAgentState::load(MemoryEventStore::new()).await?;
    let first = state
        .apply_ops(
            ActorRef::agent("demo"),
            vec![StateOp::CreateNode {
                id: NodeId::new("goal_1"),
                kind: "goal".to_string(),
                props: json!({ "title": "Improve retry reliability" }),
            }],
        )
        .await?;
    state
        .apply_ops(
            ActorRef::agent("demo"),
            vec![StateOp::CreateNode {
                id: NodeId::new("task_1"),
                kind: "task".to_string(),
                props: json!({ "title": "Investigate timeout" }),
            }],
        )
        .await?;

    let fork = state
        .fork_at_event(ForkId::new("fork_before_task"), Some(first))
        .await?;
    let diff = diff_graphs(&fork.graph, &state.graph().await);
    println!("fork_nodes={}", fork.graph.nodes.len());
    println!("current_nodes={}", state.graph().await.nodes.len());
    println!("added_nodes={:?}", diff.added_nodes);
    Ok(())
}

examples/typed_pack.rs (line 48)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let state = YoAgentState::load(MemoryEventStore::new()).await?;
    let mut runtime = YoAgentRuntime::new(state.clone());
    runtime.register_pack(
        Pack::new(PackId::new("pack_lineage"), "lineage", "0.1.0")
            .add_object_type(ObjectType::new("goal").require("title"))
            .add_object_type(ObjectType::new("task").require("title"))
            .add_relation_type(
                RelationType::new("serves")
                    .from_kind("task")
                    .to_kind("goal"),
            ),
    );

    runtime
        .create_typed_node(
            ActorRef::agent("demo"),
            NodeId::new("goal_1"),
            "goal",
            json!({ "title": "Improve retry reliability" }),
        )
        .await?;
    runtime
        .create_typed_node(
            ActorRef::agent("demo"),
            NodeId::new("task_1"),
            "task",
            json!({ "title": "Investigate timeout" }),
        )
        .await?;
    runtime
        .create_typed_relation(
            ActorRef::agent("demo"),
            NodeId::new("task_1"),
            "serves",
            NodeId::new("goal_1"),
            json!({}),
        )
        .await?;

    println!("{}", serde_json::to_string_pretty(&state.graph().await)?);
    Ok(())
}

pub async fn get_node(&self, node_id: NodeId) -> Option<Node>

pub async fn outgoing( &self, node_id: NodeId, rel: Option<&str>, ) -> Vec<Relation>

pub async fn incoming( &self, node_id: NodeId, rel: Option<&str>, ) -> Vec<Relation>

pub async fn related(&self, node_id: NodeId) -> Vec<Relation>

pub async fn patches_for_failure(&self, failure_id: NodeId) -> Vec<Node>

pub async fn evals_for_patch(&self, patch_id: PatchId) -> Vec<Node>

pub async fn lineage(&self, node_id: NodeId) -> Lineage

Examples found in repository

examples/behavior_subscription.rs (line 44)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let state = YoAgentState::load(MemoryEventStore::new()).await?;
    let mut runtime = YoAgentRuntime::new(state.clone());

    runtime.register_behavior(FnBehavior::new(
        BehaviorId::new("behavior_failure_to_task"),
        EventPattern::Kind("failure.observed".to_string()),
        |_ctx: BehaviorContext, event: Event| async move {
            let title = event
                .payload
                .get("title")
                .and_then(|value| value.as_str())
                .unwrap_or("Investigate failure");
            Ok(vec![StateOp::CreateNode {
                id: NodeId::new("task_from_failure"),
                kind: "task".to_string(),
                props: json!({
                    "title": format!("Investigate: {title}"),
                    "status": "Open",
                    "created_by_behavior": "behavior_failure_to_task",
                }),
            }])
        },
    ));

    runtime
        .emit_event(Event::new(
            ActorRef::agent("demo"),
            "failure.observed",
            json!({ "title": "retry timeout loses state" }),
        ))
        .await?;

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

examples/basic_lineage.rs (line 41)

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

    let failure = NodeId::new("failure_retry_timeout");
    let hypothesis = NodeId::new("hypothesis_retry_state_lost");

    state
        .apply_ops(
            actor,
            vec![
                StateOp::CreateNode {
                    id: failure.clone(),
                    kind: "failure".to_string(),
                    props: json!({
                        "title": "Retry state is lost after timeout",
                        "summary": "The next retry starts from attempt zero."
                    }),
                },
                StateOp::CreateNode {
                    id: hypothesis.clone(),
                    kind: "hypothesis".to_string(),
                    props: json!({
                        "title": "Attempt count is scoped to the cancelled future"
                    }),
                },
                StateOp::CreateRelation {
                    from: hypothesis.clone(),
                    rel: "explains".to_string(),
                    to: failure,
                    props: json!({}),
                },
            ],
        )
        .await?;

    print!("{}", state.lineage(hypothesis).await.to_markdown());
    Ok(())
}

examples/patch_eval_decision.rs (line 84)

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 (line 82)

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 (line 96)

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(())
}

pub async fn record_run_started( &self, actor: ActorRef, run_id: RunId, task: impl Into<String>, ) -> Result<EventId, StateError>

pub async fn record_run_finished( &self, actor: ActorRef, run_id: RunId, outcome: impl Into<String>, ) -> Result<EventId, StateError>

pub async fn record_goal(&self, goal: Goal) -> Result<EventId, StateError>

Examples found in repository

examples/goal_lineage.rs (line 21)

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(())
}

pub async fn update_goal_status( &self, goal_id: GoalId, status: GoalStatus, reason: Option<String>, ) -> Result<EventId, StateError>

pub async fn record_task(&self, task: Task) -> Result<EventId, StateError>

Examples found in repository

examples/goal_lineage.rs (line 32)

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(())
}

pub async fn update_task_status( &self, task_id: TaskId, status: TaskStatus, reason: Option<String>, ) -> Result<EventId, StateError>

pub async fn record_observation( &self, actor: ActorRef, observation: Observation, ) -> Result<EventId, StateError>

pub async fn record_hypothesis( &self, actor: ActorRef, hypothesis: Hypothesis, explains: Option<NodeId>, ) -> Result<EventId, StateError>

pub async fn record_failure( &self, actor: ActorRef, failure_id: NodeId, title: impl Into<String>, summary: impl Into<String>, ) -> Result<EventId, StateError>

Examples found in repository

examples/patch_eval_decision.rs (lines 14-19)

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 14-19)

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 36-41)

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(())
}

pub async fn record_eval_result( &self, actor: ActorRef, eval_id: NodeId, patch_id: PatchId, command: impl Into<String>, passed: bool, ) -> Result<EventId, StateError>

Examples found in repository

examples/patch_eval_decision.rs (lines 50-56)

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 57-63)

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 77-83)

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(())
}

pub async fn record_eval( &self, actor: ActorRef, eval: EvalResult, patch_id: Option<PatchId>, ) -> Result<EventId, StateError>

pub async fn record_decision( &self, actor: ActorRef, decision_id: NodeId, patch_id: PatchId, approved: bool, reason: impl Into<String>, ) -> Result<EventId, StateError>

Examples found in repository

examples/patch_eval_decision.rs (lines 59-65)

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 66-72)

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(())
}

pub async fn record_decision_node( &self, actor: ActorRef, decision: Decision, target: Option<NodeId>, ) -> Result<EventId, StateError>

pub async fn record_project_snapshot( &self, actor: ActorRef, snapshot: ProjectSnapshot, ) -> Result<EventId, StateError>

pub async fn record_model_call( &self, actor: ActorRef, call: ModelCall, ) -> Result<EventId, StateError>

pub async fn record_tool_call( &self, actor: ActorRef, call: ToolCall, ) -> Result<EventId, StateError>

pub async fn record_frame( &self, actor: ActorRef, frame: Frame, ) -> Result<EventId, StateError>

pub async fn link( &self, actor: ActorRef, from: NodeId, rel: impl Into<String>, to: NodeId, ) -> Result<EventId, StateError>

Examples found in repository

examples/goal_lineage.rs (lines 44-49)

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(())
}

pub async fn fork_at_event( &self, fork_id: ForkId, parent_event: Option<EventId>, ) -> Result<ForkSnapshot, StateError>

Examples found in repository

examples/replay_and_fork.rs (line 31)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let state = YoAgentState::load(MemoryEventStore::new()).await?;
    let first = state
        .apply_ops(
            ActorRef::agent("demo"),
            vec![StateOp::CreateNode {
                id: NodeId::new("goal_1"),
                kind: "goal".to_string(),
                props: json!({ "title": "Improve retry reliability" }),
            }],
        )
        .await?;
    state
        .apply_ops(
            ActorRef::agent("demo"),
            vec![StateOp::CreateNode {
                id: NodeId::new("task_1"),
                kind: "task".to_string(),
                props: json!({ "title": "Investigate timeout" }),
            }],
        )
        .await?;

    let fork = state
        .fork_at_event(ForkId::new("fork_before_task"), Some(first))
        .await?;
    let diff = diff_graphs(&fork.graph, &state.graph().await);
    println!("fork_nodes={}", fork.graph.nodes.len());
    println!("current_nodes={}", state.graph().await.nodes.len());
    println!("added_nodes={:?}", diff.added_nodes);
    Ok(())
}

pub async fn diff_with(&self, other: &Graph) -> GraphDiff

Trait Implementations

impl<S: EventStore> Clone for YoAgentState<S>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S: Debug + EventStore> Debug for YoAgentState<S>

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

Formats the value using the given formatter.