Struct EngineState 

pub struct EngineState {

    pub tasks: HashMap<StepId, TaskState>,
    pub sessions: HashMap<SessionId, OperatorSession>,
    pub prompts: HashMap<(StepId, u32), Value>,
    pub systems: HashMap<(StepId, u32), Option<String>>,
    pub agent_contexts: HashMap<(StepId, u32), AgentContextView>,
    pub context_policies: HashMap<(StepId, u32), ContextPolicy>,
    pub tokens: HashMap<String, CapTokenRecord>,
    pub worker_handles: HashMap<String, String>,
    pub pending_resumes: HashMap<ResumeKey, ResumePending>,
    pub task_notifies: HashMap<StepId, Arc<Notify>>,
    pub resources: HashMap<String, Value>,
    pub output_store: HashMap<(StepId, u32), Vec<OutputEvent>>,
    pub event_log_tail: Vec<Event>,
    pub event_log_max: usize,
}

The single Mutex-guarded blob of engine flow state, accessed only through Engine::with_state (see the R1-R4 discipline documented there).

Fields

tasks: HashMap<StepId, TaskState>

All known tasks, keyed by StepId.

sessions: HashMap<SessionId, OperatorSession>

All attached/detached sessions, keyed by SessionId.

prompts: HashMap<(StepId, u32), Value>

Per-(task_id, attempt) prompt/directive value, seeded from TaskSpec.initial_directive and fetched via fetch_prompt. Held as serde_json::Value end-to-end (issue #18): the render down to String (strings verbatim, anything else serde-stringified) happens only at the two consumer boundaries — the Worker HTTP path (Engine::fetch_worker_payload* → WorkerPayload.prompt: String) and the WS Spawn frame text render (operator_ws::session::default_spawn_directive_with_task_directive). Engine-internal storage and Engine::fetch_prompt keep the Value end-to-end, so Step.in Object / Array seeds are not prematurely flattened.

systems: HashMap<(StepId, u32), Option<String>>

Per-attempt system_prompt: AgentDef.profile.system_prompt is baked at compile time, rendered inside OperatorSpawner::spawn, and stashed here for the SubAgent to fetch alongside its prompt via HTTP /v1/worker/prompt. The value is Option<String> so a missing profile can be distinguished: an absent key means “not yet baked”, while Some(None) means “baked and profile is explicitly absent”.

agent_contexts: HashMap<(StepId, u32), AgentContextView>

Per-attempt materialized crate::core::agent_context::AgentContextView (Contract C, GH #20) — the Worker axis’s read-back source. Written by crate::middleware::agent_context::AgentContextMiddleware (innermost spawner layer) at dispatch time; read by Engine::fetch_worker_payload{,_trusted} and threaded into WorkerPayload.context. Keyed the same way as prompts / systems — Ctx itself is not stored, so the view has to be snapshotted here to still be servable at fetch time.

context_policies: HashMap<(StepId, u32), ContextPolicy>

Per-attempt effective mlua_swarm_schema::ContextPolicy resolved by AgentContextMiddleware (the same policy already applied to the agent_contexts snapshot at this key) — the projection-adapter ST5 Worker axis addition. Engine::context_policy_for reads it back so crates/mlua-swarm-server/src/worker.rs’s GET /v1/worker/prompt handler can filter the WorkerPayload.context.steps pointer list via ContextPolicy::allows_step without re-deriving the policy from the Blueprint at fetch time. An absent entry (pre-ST5 spawns, or a spawner stack that never layered AgentContextMiddleware) means pass-all (mlua_swarm_schema::ContextPolicy::default()).

TODO(GH #23): (1) neither this map nor agent_contexts (nor prompts / systems) has a removal path — entries accumulate for the process lifetime; a long-running server needs a task-completion sweep. (2) This map and agent_contexts share a key and are only kept in sync by convention (single insert site in AgentContextMiddleware); folding both values into one map of a (view, policy) struct would make the pairing structural.

tokens: HashMap<String, CapTokenRecord>

All minted CapToken records, keyed by token fingerprint (CapToken::fingerprint = SHA-256 of the nonce; issue #14 — the key is loggable, the nonce is not).

worker_handles: HashMap<String, String>

Short worker handle (wh-XXXXXXXX, 12 chars) → token-fingerprint lookup map. Resolves the worker_handle field a SubAgent receives with its prompt. There is no signature verification: task_id is resolved by a plain HashMap lookup — deliberately thin for the local running over WebSocket, and adopted specifically to remove the base64 copy-paste failure mode.

pending_resumes: HashMap<ResumeKey, ResumePending>

Outstanding query_senior suspensions awaiting resume.

task_notifies: HashMap<StepId, Arc<Notify>>

Per-task notifier — notify_waiters fires on every task-status change. Used by poll_task on the caller side, and by callers that need to await again after detach/reattach.

resources: HashMap<String, Value>

Arbitrary named resources set via set_resource and read via fetch_data.

output_store: HashMap<(StepId, u32), Vec<OutputEvent>>

Per-attempt output-event log. The SpawnerAdapter appends via submit_output; the dispatch path pulls the terminal OutputEvent::Final off the tail and decides Pass / Blocked.

event_log_tail: Vec<Event>

Bounded in-process tail of recent Events (most recent last), trimmed to event_log_max by push_event.

event_log_max: usize

Maximum length of event_log_tail before older entries are dropped.

Implementations

impl EngineState

pub fn new() -> Self

Construct an empty EngineState with event_log_max = 1024.

pub fn ensure_task_notify(&mut self, task_id: &StepId) -> Arc<Notify>

Ensure a per-task Notify exists; return the existing one if any.

pub fn push_event(&mut self, ev: Event)

Append ev to event_log_tail, trimming the oldest entries once event_log_max is exceeded.

Trait Implementations

impl Debug for EngineState

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

Formats the value using the given formatter.

impl Default for EngineState

fn default() -> Self

Returns the “default value” for a type.