Struct Manifest 

pub struct Manifest {

    pub schema_version: u32,
    pub applied_seq: u64,
    pub run_id: RunId,
    pub kind: Kind,
    pub lifecycle: Lifecycle,
    pub title: String,
    pub status: Status,
    pub created_at: DateTime<Utc>,
    pub updated_at: DateTime<Utc>,
    pub source_repo: Option<String>,
    pub source_branch: Option<String>,
    pub worktree_root: Option<String>,
    pub managed_tmux_session: Option<String>,
    pub notify_cmd: Option<String>,
    pub node_count: u32,
    pub open_discussions: u32,
    pub pending_spinoffs: u32,
    pub parent_run_id: Option<RunId>,
    pub parent_node_id: Option<NodeId>,
}

manifest.json (design.md §1.2).

Fields

schema_version: u32

State-schema version this file was written with.

applied_seq: u64

Watermark: the highest event seq whose projection fold is durably committed. Events in events.jsonl with seq > applied_seq are unapplied tail events — replayed into the projections on the next lock acquisition before any new append (see crate::events::append_and_apply_event). This is what makes append-then-apply atomic across a reducer crash: the event log can run ahead of the projections, but the gap is always healed before the next writer observes stale state.

#[serde(default)] so a legacy manifest.json written before this field existed deserializes with applied_seq = 0. Such a manifest self-migrates on its next write: the catch-up replay re-folds the whole log — every event a no-op, because legacy state was already projected synchronously under the old append-then-apply path — and advances the watermark to last_seq. No separate migration pass or schema bump is required (the field is purely additive to a derived-cache file).

run_id: RunId

Unique run identifier (ULID). Validated on read.

kind: Kind

Kind of work this run performs.

lifecycle: Lifecycle

Execution lifecycle (autonomous vs interactive).

title: String

Human-readable run title.

status: Status

Current aggregate run status.

created_at: DateTime<Utc>

When the run was created.

updated_at: DateTime<Utc>

When the manifest was last modified.

source_repo: Option<String>

Source repository the run operates on, if any.

source_branch: Option<String>

Branch the run was started from, if any.

worktree_root: Option<String>

Root directory under which this run’s worktrees live, if any.

managed_tmux_session: Option<String>

tmux session orchestratectl created to host this run’s headless windows (--headless / --tmux-session <name>), if any. None for a foreground run whose window lives in the user’s own session — that session is never a teardown target. When set, the supervisor kills this session once its last orchestratectl-owned window is torn down and only the synthetic bootstrap shell window remains, so an empty headless session is not left behind (issue headless-tmux-session-not-torn-down). #[serde(default)] keeps a manifest written before this field existed readable.

notify_cmd: Option<String>

Completion-notification command registered at run create --notify, if any. When the run reaches a terminal state (done | failed | cancelled) the supervisor runs this command (at-least-once, deduped on a durable run.notified marker event — the healthy path fires once, a crash between firing and recording may re-fire) with OCTL_RUN_ID / OCTL_STATUS / OCTL_SUMMARY (and OCTL_RUN_KIND / OCTL_RUN_TITLE) in its environment, BEFORE teardown removes the worktree/window. This is how a spawning session learns of completion without polling (issue no-completion-notification-to-parent). None for a run created without --notify; #[serde(default)] keeps a manifest written before this field existed readable.

node_count: u32

Number of nodes created in this run (denormalized counter).

open_discussions: u32

Count of currently open discussions (denormalized counter).

pending_spinoffs: u32

Count of currently pending spin-off proposals (denormalized counter).

parent_run_id: Option<RunId>

Run that spawned this run, if it is itself a child.

parent_node_id: Option<NodeId>

Node in the parent run that spawned this run, if any.

Trait Implementations

impl Clone for Manifest

fn clone(&self) -> Manifest

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Manifest

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Manifest

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Manifest

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.