Struct TurnActivityTrackerInner 

struct TurnActivityTrackerInner {

    active_turn: bool,
    exit_code: Option<i32>,
    provenance: Option<TurnProvenance>,
    next_turn: Option<TurnProvenance>,
    ledger: Option<TurnLedger>,
    input_during_pass: bool,
    cli_wake_pending: bool,
    continuation_expected: bool,
    continuation_provenance: Option<TurnProvenance>,
    pending_join: Option<(u64, u64)>,
    ledger_seq: u64,
    next_turn_trigger: Option<TurnTrigger>,
    pending_task_trigger: Option<TurnTrigger>,
}

Fields

active_turn: bool

exit_code: Option<i32>

provenance: Option<TurnProvenance>

What started the CURRENT turn. Cleared on every idle→active flip that isn’t labelled, so a turn only ever carries a provenance its own start reported — a stale label can never leak into a later turn.

next_turn: Option<TurnProvenance>

Told ahead of a turn that starts later — a message queued while the process spawns. Taken by the next idle→active flip.

ledger: Option<TurnLedger>

The user-facing turn this block is in, or last was in.

input_during_pass: bool

Input was written while the current pass ran: the CLI may answer it in a pass of its own straight after this one (J2).

cli_wake_pending: bool

The CLI reported a finished background task, so it will start a pass by itself to tell the model (J4). Cleared when any pass starts.

continuation_expected: bool

Input reached the CLI during the pass that just ended, which it may answer in a pass of its own straight after (J2). Good only while that turn settles: a later pass the CLI starts is something else’s.

continuation_provenance: Option<TurnProvenance>

What started that pass: a continuation answers the same input, so it carries the same provenance (self-quit gate, §6.3).

pending_join: Option<(u64, u64)>

The turn a held message being sent now should join, and when srv was told: for controllers whose pass starts carry no input (hint_join).

ledger_seq: u64

The last TurnLedger::seq stamped, across turns.

next_turn_trigger: Option<TurnTrigger>

The trigger of a message queued for the next turn (hint_next_turn).

pending_task_trigger: Option<TurnTrigger>

The task the CLI last reported finished, for the pass it wakes for.

Implementations

impl TurnActivityTrackerInner

fn stamp(&mut self, before: &Option<TurnLedger>) -> Option<TurnLedger>

The ledger to publish after a change: stamped with the next seq when it differs from before.

fn start_unlabelled(&mut self)

idle→active with no label: take the queued hint, if any.

fn note_input_during_pass(&mut self, trigger: Option<TurnTrigger>)

Mid-pass input: the turn will expect a next pass when this one ends.

fn begin_pass( &mut self, start: PassStart, trigger: Option<TurnTrigger>, now: u64, )

A pass starts (idle→active): join the current turn or open a new one (turn-model spec §4.3).

fn end_pass(&mut self, now: u64, provenance: Option<TurnProvenance>)

The running pass ended (active→idle). The turn waits for a next pass when one is expected, and is over otherwise.