Struct LifecycleConfig 

pub struct LifecycleConfig {
    pub task_acceptance: TaskAcceptance,
    pub after_task: AfterTask,
    pub queue_depth: usize,
    pub input_timeout_secs: Option<u64>,
    pub conversation_mode: ConversationMode,
    pub max_task_reopens: u32,
    pub shell_grace_secs: u64,
    pub delegation_deadline_secs: u64,
}

Fields

task_acceptance: TaskAcceptance

after_task: AfterTask

queue_depth: usize

input_timeout_secs: Option<u64>

If set, request-input calls that receive no follow-up within this many seconds transition the task to “failed” with reason “input-timeout”. Absent = wait indefinitely.

conversation_mode: ConversationMode

Whether tasks sharing a contextId accumulate conversation history across turns. Stateless (default): each task is fully independent; Threaded: history is loaded and persisted per contextId within a session.

max_task_reopens: u32

Maximum times an on-task-end hook may reopen a single task (re-run its agent loop with injected feedback). Defaults to 1 when absent. 0 disables reopening entirely. Unlike inference.max_turns, 0 is a valid explicit value. Reopening never grants turns past inference.max_turns — the two budgets share one cumulative turn count.

shell_grace_secs: u64

How long a shell command runs in the foreground before it is demoted to the background. Defaults to 10 seconds. A command that exits inside this window returns its output to the turn as it always has; one that outruns it hands the turn a handle, keeps running, and reports back later as a completion-origin task. 0 demotes at the first poll after the spawn, so effectively every command detaches.

delegation_deadline_secs: u64

The single bound on a delegation, covering both waits one can have: how long a sub-capsule started by delegate-task is watched, and how long a plan capsule step waits for its answer. Defaults to 600 seconds. Absent is a ceiling rather than an absence: a capsule that never declares this one is still bounded, because an unbounded delegation leaves a wedged sub-capsule running for as long as the capsule that started it. 0 gives up at the first poll after the task is delivered, the same reading shell_grace_secs: 0 has.

Reaching the deadline ends the sub-capsule. A delegate-task caller is told in a completion-origin task carrying status: terminated and a detail naming the bound; a plan step’s call returns timed_out. The clock starts when the sub-capsule reports itself ready, not when its process is spawned, so a slow host does not spend this window on staging. MURMUR_DELEGATION_TIMEOUT_SECS overrides this value when it names a positive number of seconds.

Implementations

impl LifecycleConfig

pub fn can_receive_background_tasks(&self) -> bool

Whether a session under this lifecycle is still there to receive work that arrives after the task which started it ended — a demoted shell command’s completion, a delegation’s outcome.

queue + sleep is the only combination that qualifies, and the delegation lane and the shell lane must agree on it: a capsule warned about one and not the other would be told its lifecycle is both adequate and inadequate for the same reason.

Trait Implementations

impl Clone for LifecycleConfig

fn clone(&self) -> LifecycleConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LifecycleConfig

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

Formats the value using the given formatter.

impl Default for LifecycleConfig

fn default() -> LifecycleConfig

Returns the “default value” for a type.

impl Eq for LifecycleConfig

impl PartialEq for LifecycleConfig

fn eq(&self, other: &LifecycleConfig) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for LifecycleConfig