Struct ActiveSeat 

pub struct ActiveSeat {
    pub node: String,
    pub started_at: Timestamp,
    pub timeout_secs: u64,
    pub attempt: usize,
    pub task: Option<String>,
    pub command: Option<String>,
    pub index: Option<usize>,
    pub total: Option<usize>,
}

A seat currently mid-answer: a prompt was sent and no reply has landed yet.

This is not the whole story of “is it alive” — a daemon killed mid-wave leaves its last wave’s entries here forever, since nothing ran to clear them. A reader must cross-check a live daemon’s heartbeat (daemon::is_working_on) before trusting one of these as “still running” rather than “abandoned”. RunState::clear_active is what keeps that leftover from surviving into the next attempt at this run: execute calls it before doing anything else, so a resumed run never carries a stale entry into its own report before the next wave repopulates it.

Deliberately carries no agent id: an implementer’s agent is no secret, but a judge or reviewer seat is blind (SeatState::key is keyed by seat, never agent, for exactly this reason), and this struct has no way to tell which kind of seat it describes. The seat key alone — already in the map this lives under — is what every caller needs to say which seat is running.

The same map also carries entries for shell-command work that runs outside any seat — verify.e2e, verify.gate — keyed by the task’s own name ("e2e", "gate") rather than a seat key. Self::task is Some only for those; it is how a reader tells the two kinds of entry apart without a second map, a second route, or a second SSE reason to poll for — see RunState::seats_active / RunState::tasks_active for the accessors that split them back apart. A task entry is exactly as blind as a seat entry: no agent runs it, so there is nothing to leak, and Self::command carries only the shell command being run, never anything about who is running it.

Fields

node: String

Node the seat is answering for, e.g. implement, judge, review. For a task entry, the node the command list runs under (verify, gate).

started_at: Timestamp

When this attempt — or, for a task entry, this one command — was started. A task entry’s timer resets at every command boundary, because verify.e2e / verify.gate apply their timeout per command, not once across the whole list — see RunState::task_command.

timeout_secs: u64

The wall-clock budget for this attempt (a seat) or this one command (a task entry).

attempt: usize

0 for the first ask, N for the Nth nudge or resume. For a task entry, 0 for the first pass over the command list, N for the Nth retry (see run_e2e_with_retry’s build/link retry).

task: Option<String>

None for a seat; Some("e2e") / Some("gate") for a running command-list task. This is the type tag that lets both kinds of entry share one map without a task ever being mistaken for a (blind) seat — see this struct’s own doc. Omitted from JSON when absent (the common, seat case), rather than written out as a literal null on every one of a run’s seat entries.

command: Option<String>

The command currently running, task entries only. Never set on a seat entry — a seat has no command, only a prompt, and a prompt is not safe to show mid-run (see this struct’s blindness note).

index: Option<usize>

1-based position of Self::command within the task’s command list.

total: Option<usize>

Number of commands in the task’s list.

Implementations

impl ActiveSeat

pub fn elapsed_secs(&self, now: Timestamp) -> i64

Seconds since this attempt was sent.

pub fn remaining_secs(&self, now: Timestamp) -> i64

Seconds left before this attempt’s own timeout fires, floored at zero rather than going negative once the CLI has overrun its budget.

Trait Implementations

impl Clone for ActiveSeat

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ActiveSeat

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ActiveSeat

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for ActiveSeat

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

where __S: Serializer,

Serialize this value into the given Serde serializer.