everruns-engine

Shared Input/Reason/Act execution and sans-I/O turn planning for Everruns hosts.

everruns-engine owns the abstract Execution contract, its serializable TurnExecution state machine, the portable Input/Reason/Act algorithms, and the deterministic turn planner. It transforms phase outcomes and host-resolved facts into the next plan and ordered lifecycle effects.

Planning is pure. Execution effects cross injected contracts from everruns-core and everruns-provider; the engine does not select a store, transport, process runner, server, worker, platform, or durable backend.

It is a focused implementation crate in the Everruns ecosystem. Framework applications use everruns; runtime, worker, durable, and custom hosts share this kernel to keep phase behavior, event ordering, and turn semantics aligned.

Quick Example

use everruns_engine::{TurnPlan, TurnState};

fn accepts_plan(_state: &TurnState, _plan: &TurnPlan) {}
# let _ = accepts_plan;

What It Provides

• Serializable turn state and activity outcomes
• A stateful, serializable execution machine shared by all drivers
• An open execution contract for immediate and checkpointed implementations
• Pure next-turn planning functions
• Portable Input, Reason, and Act executors over injected contracts
• Engine-owned phase input/result types and concrete execution hooks
• Explicit host facts and lifecycle effects
• Shared semantics and event ordering for in-process and durable hosts

Documentation

• Framework custom backends
• API reference

License

Licensed under the MIT License.