Struct Forge 

pub struct Forge { /* private fields */ }

Main Forge runtime

Implementations

impl Forge

pub fn node_id(&self) -> NodeId

Get the node ID

pub async fn state(&self) -> RuntimeState

Get current runtime state

pub fn uptime_secs(&self) -> u64

Get uptime in seconds

pub fn metrics(&self) -> Option<&Arc<ForgeMetrics>>

Get metrics instance

pub fn store(&self) -> &BoxedStateStore

Get the state store

pub fn router(&self) -> &BoxedMoERouter

Get the MoE router

pub fn has_nomad(&self) -> bool

Check if Nomad is configured

pub fn register_node(&self, node: NodeResources)

Register a node available to the embedded scheduler / reconcile loop.

Register nodes before Forge::run, which seeds the reconcile loop with the registered set.

pub async fn new_reconciler(&self) -> Result<Reconciler>

Build a Reconciler that shares this runtime’s state store and is seeded with the registered nodes. The reconciler converges submitted jobs (persisted under keys::JOBS) onto node assignments.

Forge::run spawns one automatically; this is exposed for tests and advanced embedding. It uses a fresh autoscaler with the same config as the runtime’s — the reconciler is the autoscaling authority for the loop.

pub async fn run(self) -> Result<()>

Run the Forge control plane

pub async fn shutdown(&self) -> Result<()>

Shutdown the control plane

pub fn signal_shutdown(&self)

Signal shutdown

pub fn shutdown_receiver(&self) -> Receiver<()>

Subscribe to shutdown signal

pub async fn submit_job(&self, job: Job) -> Result<String>

Submit a job

pub async fn submit_sim_cell(&self, cell: SimCell) -> Result<String>

Submit a simulation cell (world shard + co-resident agent policies) for gang scheduling. Persisted under keys::simcell(id); the reconcile loop picks it up and gang-schedules its members all-or-nothing (co-located per the cell’s crate::scheduler::sim::CoPlacement).

pub fn get_job(&self, job_id: &str) -> Option<Job>

Get a job by ID

pub fn list_jobs(&self) -> Vec<Job>

List all jobs

pub async fn stop_job(&self, job_id: &str, purge: bool) -> Result<()>

Stop a job

pub async fn scale_job( &self, job_id: &str, group: &str, count: u32, ) -> Result<()>

Scale a job’s task group

pub async fn route(&self, input: &str) -> RouteResult

Route an input to an expert

pub fn register_expert(&self, expert: Expert)

Register an expert

pub fn update_expert_load(&self, index: usize, load: f64)

Update expert load

pub async fn evaluate_scaling( &self, job_id: &str, cpu: f64, memory: f64, instances: u32, ) -> ScalingDecision

Evaluate autoscaling for a job