Struct RunResult 

pub struct RunResult {
    pub outcome: RunOutcome,
    pub run_id: i64,
    pub remembered: Vec<Rule>,
}

The result of a run, including the persisted run id for audit.

Three things, and the run_id is the one that outlives the process. Every step, refusal, spawn and budget draw is in the store under it, so a run is still readable long after the program that drove it exited — and it is the handle every resume* entry point takes:

use io_harness::{run_with, ApproveAll, OpenRouter, Policy, RunOutcome, Store, TaskContract};

let store = Store::open("runs.db")?;
let result = run_with(contract, &OpenRouter::from_env()?, &store, policy, &ApproveAll).await?;

// What it cost and how long it took, read back from the same row an auditor
// would read — so the caller and the audit cannot disagree. `None` while a
// run is paused awaiting a human: there is no ending to summarise yet.
if let Some(summary) = result.summary(&store)? {
    println!("{} tokens", summary.tokens);
}

// Rules an approver asked to remember. The crate applied them for the rest of
// this run and hands them back here; persisting them across runs is the
// caller's decision, because config files are the application's to own.
for rule in &result.remembered {
    println!("remember: {:?} {} {:?}", rule.act, rule.pattern, rule.effect);
}

// Keep the id if the run is not finished — it is all a later process needs.
if !matches!(result.outcome, RunOutcome::Success { .. }) {
    println!("resume run {}", result.run_id);
}

Fields

outcome: RunOutcome

Why the run stopped.

run_id: i64

The run’s id in the Store, for reading its trace back.

remembered: Vec<Rule>

Rules an approver asked to remember during this run. The crate applies them for the rest of the run and hands them back here; persisting them across runs is the caller’s decision, since config files are app-owned.

Implementations

impl RunResult

pub fn summary(&self, store: &Store) -> Result<Option<RunSummary>>

What this run cost and whether it worked, read back from the store.

Added in 0.12.0. Before it, a caller holding a RunResult had an outcome discriminant and a run_id: spend needed a follow-up query, and latency was not recorded anywhere at all.

None when the run has not finished — a run paused awaiting a human has no ending to summarise yet.

A method rather than a field, deliberately. A field would have to be filled at every one of the entry points’ return sites, including the ones that return Err and never build a RunResult, so the two could drift. Reading it from the store means the caller and an auditor are looking at the same row by construction. It also keeps this struct’s existing exhaustive-pattern compatibility intact: no new field, no break.

Trait Implementations

impl Clone for RunResult

fn clone(&self) -> RunResult

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RunResult

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

Formats the value using the given formatter.