Struct RunningRecord 

pub struct RunningRecord {

    pub session_id: String,
    pub url: Option<String>,
    pub pid: u32,
    pub process_start: String,
    pub capsule_name: String,
    pub capsule_version: String,
    pub workdir: PathBuf,
    pub records_dir: PathBuf,
    pub outlives_launcher: bool,
    pub started_at: String,
    pub door_token: Option<DoorToken>,
    pub credentials: BTreeMap<String, DoorToken>,
    pub formation_id: Option<FormationId>,
    pub formation_member: Option<String>,
    pub formation_entry: bool,
    pub formation_lifeline: bool,
    pub formation_launcher: Option<ProcessIdentity>,
    pub spawned_by: Option<String>,
    pub unconfined: bool,
}

Which process holds one running session, and where its door is when it has one.

Every field but door_token, credentials, formation_id, formation_member, formation_entry, formation_lifeline, formation_launcher and spawned_by is required, and each of those eight is omitted when it does not apply, so a standalone session’s record carries the ten required keys alone. There is no version field: a record that does not deserialize names no process that could be checked, and is pruned, which is what “the record is a hint” already means — except one an older mur wrote, which scan recognises by its missing records_dir and no reader removes.

Fields

session_id: String

The session this door answers for, compared against the agent card by layer 3.

url: Option<String>

host:port the A2A door is bound to. None for a script capsule, which binds no door; always serialized, as null then.

pid: u32

The process holding the door.

process_start: String

That process’s start time, as an opaque platform-local token — see process_start_token.

capsule_name: String

capsule_version: String

workdir: PathBuf

The session’s work folder. The trace and results are in Self::records_dir.

records_dir: PathBuf

The session’s records directory, ~/.murmur/records/<workdir root>/<session-id>, where a reader finds the trace of what it is watching, outside the workdir the capsule’s commands write. Required. A JSON object with a string session_id and no records_dir key is a record an older mur wrote: scan lists it in RecordScan::older_mur, and nothing reads its other fields or removes it.

outlives_launcher: bool

Whether the capsule survives the window that launched it — true when the launching process had no controlling terminal.

started_at: String

RFC 3339, in UTC.

door_token: Option<DoorToken>

The operator token of a door declaring network.authentication, which the host tools present to it. Absent for a public door, and in a record an older runtime wrote. Its Debug is redacted, and it is serialized only here, into a file held at 0600.

credentials: BTreeMap<String, DoorToken>

The tokens of the credentials network.authentication.credentials declares, by name. The operator token is door_token, never an entry here. Empty, and omitted, for a public door, for one declaring no credentials, and in a record an older runtime wrote. Every scope of every entry is also a scope of door_token, so holding them beside it exposes nothing the file did not already.

formation_id: Option<FormationId>

The formation this session is a member of, so a reader can tell a formation’s records from unrelated sessions on the machine. Absent for a session in no formation, and in a record an older runtime wrote. It groups records and grants nothing. A value that is not a formation id makes the whole record unreadable, which list prunes like any other.

formation_member: Option<String>

The member’s roster name, so a reader can tell apart members running the same capsule. Present only for a session mur run --roster launched as a member, and then the same name as the trace’s session_start.formation_member. Absent for a session in no formation, for a member’s delegated child, for a session joined to a formation through MURMUR_FORMATION_ID alone, and in a record an older runtime wrote. It labels the record and grants nothing. A value that is not a member name makes the whole record unreadable.

formation_entry: bool

The session is its formation’s entry member: the member mur run --roster hands the formation’s task, or whose door takes the formation’s tasks. Set from the member’s formation channel. Absent when false: for every other member, every session in no formation, a member’s delegated child, and in a record an older runtime wrote.

formation_lifeline: bool

The session holds a formation lifeline: its launcher ends it by closing that lifeline, and nothing else needs to. Absent when false.

formation_launcher: Option<ProcessIdentity>

The formation launcher that started this session, as the launcher named itself on the member’s formation channel. Absent for a session no launcher started, and for a member whose launcher could not read its own start time. A value that is not an object with a pid and a process_start makes the whole record unreadable.

spawned_by: Option<String>

The session id of the session that delegated to this one. A delegated child holds its spawner’s lifeline and ends with it. Absent for a session nothing delegated to.

unconfined: bool

The session runs unconfined: its commands run as the operator. Absent when false.

Implementations

impl RunningRecord

pub fn identity(&self) -> ProcessIdentity

The process this record names.

Trait Implementations

impl Clone for RunningRecord

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 RunningRecord

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RunningRecord

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for RunningRecord

impl PartialEq for RunningRecord

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for RunningRecord

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for RunningRecord