Struct TurnActivityTracker 

pub struct TurnActivityTracker {
    block_id: String,
    inner: Mutex<TurnActivityTrackerInner>,
    publisher: Mutex<Option<Arc<dyn Fn(&TurnLedger) + Send + Sync>>>,
    publish_order: Mutex<()>,
    clock: Box<dyn Fn() -> u64 + Send + Sync>,
}

Per-block turn-activity tracker.

Fields

block_id: String

inner: Mutex<TurnActivityTrackerInner>

publisher: Mutex<Option<Arc<dyn Fn(&TurnLedger) + Send + Sync>>>

publish_order: Mutex<()>

Taken before inner is released and held through the publish, so ledgers go out in seq order. The broker keeps the last one for replay, so an older one published last would be what a new subscriber gets (#4492). Lock order: inner → publish_order.

clock: Box<dyn Fn() -> u64 + Send + Sync>

Implementations

impl TurnActivityTracker

pub fn new(block_id: String) -> Self

pub fn for_block(block_id: String, broker: Option<&Arc<Broker>>) -> Self

A tracker that publishes its turn ledger on broker, when there is one.

fn with_clock( block_id: String, clock: Box<dyn Fn() -> u64 + Send + Sync>, ) -> Self

pub fn set_ledger_publisher( &self, publisher: Arc<dyn Fn(&TurnLedger) + Send + Sync>, )

Where ledger changes go (the agentturn event). Set once by the controller that owns this tracker, when it has a broker.

fn publish_in_order( &self, inner: MutexGuard<'_, TurnActivityTrackerInner>, before: Option<TurnLedger>, after: Option<TurnLedger>, )

Release inner and publish the ledger if it changed, in seq order, logging the change as a [turn] line (muxlog’s answer to “why did my timer reset”: turn-model spec §7).

fn publish_if_changed( &self, before: Option<TurnLedger>, after: Option<TurnLedger>, )

Send the ledger to the publisher, if it changed. Called after the tracker’s lock is released.

pub fn set_active_turn(&self, active: bool)

Called when a new turn starts (subprocess spawned).

pub fn mark_turn_active_returning_was_active(&self) -> bool

Atomically marks a turn active and reports whether one was already in flight (the pre-call value) — a single lock acquisition, unlike calling is_active_turn() then set_active_turn(true) separately. That two-step form is a check-then-act race: send_message (user input) and send_user_message (muxbus delivery) can run concurrently on the same block, and both reading false before either writes true lets both decide to spawn a watchdog — the exact duplicate the “only re-arm when resuming from idle” logic exists to prevent.

pub fn mark_turn_active_from(&self, input: Option<TurnInput>) -> bool

Self::mark_turn_active_returning_was_active, saying who delivered the input (turn provenance, SPEC_AGENT_SELF_QUIT §6.3):

• starting a turn records input as what started it — or, unlabelled, whatever was queued for it (else unknown);
• into a running turn, non-user input — or unlabelled input, which can’t be proven to be the user — taints it.

pub fn note_cli_task_notification(&self, summary: Option<&str>)

The CLI reported a finished background task (system/task_notification). It tells the model in a pass it starts itself: at once if it is idle, straight after the running pass otherwise.

pub fn mark_turn_active_from_cli(&self) -> bool

The CLI began a pass with no input from srv (system/init while idle). Marked active only when something explains it (a task notification, or input that reached it during the last pass), so a stray line can never leave the agent reported busy with nothing to end it. Returns whether the pass was marked (the caller then publishes status and re-arms the heartbeat).

pub fn end_pass(&self, stats: Option<PassStats>)

The CLI’s result: the running pass is over. Its figures (when the frame carries them) go to the turn it belonged to in the same step as the idle flip, so input that arrives right after can’t take them.

pub fn hint_join(&self, turn_id: u64)

A message the pane held while turn turn_id ran is about to be sent through a controller whose pass start carries no input (ACP, App Server, one-shot subprocess): the pass it starts joins that turn, as TurnInput::joins_turn does for the persistent controller (§4.3, J3).

pub fn clear_join_hint(&self)

Drop a join hint whose dispatch failed: no pass will consume it, and a later message must not.

pub fn set_exited(&self, exit_code: i32)

Called when the subprocess exits.

pub fn is_active_turn(&self) -> bool

Whether there’s an active turn in progress.

pub fn hint_next_turn(&self, input: TurnInput)

A message queued now will start a later turn (it waits for the process to spawn). Two queued before that turn starts: the second, if not the user’s, taints it.

pub fn hint_next_turn_unlabelled(&self)

An unlabelled message queued for the next turn: it can’t be proven to be the user, so a turn already labelled by an earlier queued message is tainted. (Queued first, it leaves the turn unknown anyway.)

pub fn mark_turn_active_for_queued(&self) -> bool

The turn is active because messages already accounted for are being delivered — the queue drained after a spawn, a retry flush. Not new input: an idle tracker starts the turn with whatever was queued for it, and a running turn is left as it is (ReAgent P1 on #3789 — the plain unlabelled mark tainted every freshly spawned user turn).

pub fn provenance(&self) -> Option<TurnProvenance>

What started the turn in flight, if one is and it was reported.