Struct CronScheduler 

pub struct CronScheduler {
    handles: Mutex<HashMap<String, AbortHandle>>,
    shared_store: Option<Arc<Store>>,
    http_client: Client,
    local_url: String,
    auth_key: String,
    broker: Arc<Broker>,
    delivery: OnceLock<Arc<dyn Fn(InjectionRequest, String) -> Pin<Box<dyn Future<Output = Value> + Send>> + Send + Sync>>,
}

Fields

handles: Mutex<HashMap<String, AbortHandle>>

shared_store: Option<Arc<Store>>

http_client: Client

local_url: String

auth_key: String

broker: Arc<Broker>

delivery: OnceLock<Arc<dyn Fn(InjectionRequest, String) -> Pin<Box<dyn Future<Output = Value> + Send>> + Send + Sync>>

Implementations

impl CronScheduler

pub fn new( shared_store: Option<Arc<Store>>, http_client: Client, local_url: String, auth_key: String, broker: Arc<Broker>, ) -> Arc<Self>

pub fn install_delivery( &self, delivery: Arc<dyn Fn(InjectionRequest, String) -> Pin<Box<dyn Future<Output = Value> + Send>> + Send + Sync>, )

Deliver fires in process from now on (see FireDelivery). Once; a second install is ignored.

fn publish_changed(&self)

pub async fn start(self: &Arc<Self>)

Load all enabled jobs from the DB and schedule them. Call once at startup.

pub fn schedule_job(self: &Arc<Self>, job: &CronJob)

Schedule a single job (or reschedule it after a DB change). Replaces any existing task for the same job.id. Call sites that don’t need to account for a simultaneous catch-up fire should pass job.fire_count.

fn schedule_job_with_fires(self: &Arc<Self>, job: &CronJob, initial_fires: i64)

pub fn cancel_job(&self, id: &str)

Stop (abort) a job’s scheduled task without removing it from the DB.

fn disable_job(&self, job_id: &str, reason: &str)

Disable a job in the DB (audit trail preserved, unlike delete), drop its live task handle, and notify listeners. Shared by every self-disabling reason a scheduled job’s own loop hits (max_fires, max_age_secs) — extracted so those call sites don’t each repeat the same three-step disable sequence.

pub(crate) async fn fire( &self, id: &str, prompt: &str, target: &str, target_uid: &str, created_by_uid: &str, )

Fire a cron job: deliver the prompt and record the fire in DB.

Identity M3 (spec §5.4): a job that captured its target’s UID at creation fires BY UID — a job firing at 03:00 must never resolve a name. A job with no UID (created before M3, or by a caller that did not carry one) fires by name as before, counted.

Identity M4c-3 (§6.5.9): delivered in process (FireDelivery), with the creator’s UID as attribution on this instance only — a forwarded hop never carries it. The sender name stays "cron": showing the creator’s name unsigned would make every fire of an agent-created job look forged (its key is on file under that name) and echo each fire into the creator’s pane. A job with no captured creator UID fires as before, counted.

async fn post_fire( &self, id: &str, target_agent: String, prompt: &str, ) -> Option<Value>

The pre-M4c-3 fire: POST to the local inject route with the instance key. Only until Self::install_delivery runs. None when the POST itself failed (logged here).