Struct HomeWire 

pub struct HomeWire {

    pub projects: Vec<ProjectWire>,
    pub agents: Vec<AgentWire>,
    pub fleet: Vec<FleetRow>,
    pub unseen: Vec<SessionSlot>,
    pub accounts: AccountPoolView,
    pub connectors: ConnectorsWire,
    pub dictate: DictateWire,
    pub voice: VoiceWire,
    pub cli_version: Option<Value>,
    pub forge_version: String,
    pub forge_version_short: String,
    pub boot_id: String,
    pub service_status: Option<Value>,
    pub fatal_error: Option<Value>,
    pub biometric: ReadWire<Vec<BiometricEnrolment>>,
    pub vault: Option<VaultWire>,
}

The home, as a client sees it: every read a home-scoped view makes.

The last two are the App-level state that reaches a home subscriber as an update and nothing else - a subject’s snapshot has to cover every update that subject receives, or a late subscriber sees a smaller world than one that attached at boot.

Fields

projects: Vec<ProjectWire>

agents: Vec<AgentWire>

fleet: Vec<FleetRow>

One row per project for the fleet page: the counts and the named misses (a stalled queue, a worker holding no row). A project’s own rows ride ProjectBoardWire::rows; this is the glance.

unseen: Vec<SessionSlot>

The seats whose last turn finished while no client was showing them.

A view draws a mark per row from this, and it is the fact a viewer cannot reconstruct: a turn that ended before a client attached leaves nothing in the transcript to say it went unwatched, so a client reading only the records would draw every row as settled.

accounts: AccountPoolView

The pool as both the snapshot and AccountsChanged state it; see forge_workspace::AccountPoolView.

connectors: ConnectorsWire

dictate: DictateWire

voice: VoiceWire

The speaking role’s switch and model directory: the machine-wide facts a voice control reads before it names a seat.

cli_version: Option<Value>

The claude CLI versions the core holds, as the core’s own snapshot serialises. Its crate is one this one may not name.

forge_version: String

The forge build serving this socket: the full stamp and the short one.

A client draws the short one as its server build, beside its own labelled client build. The header states which forge commit is RUNNING, and the client is a different program with a version of its own, so the two are named apart rather than one standing for both.

forge_version_short: String

boot_id: String

The server run’s own identity, minted once per process.

An ask’s number restarts with the process, so a client that kept its marks across a forge restart would read a fresh ask as one it had already announced. The run rides the roster and every mark is scoped by it, so no two runs can be confused.

service_status: Option<Value>

fatal_error: Option<Value>

The last fatal error, held by the core: an App-level event with no state behind it reaches only whoever was subscribed when it fired.

biometric: ReadWire<Vec<BiometricEnrolment>>

The device enrolments the settings page lists and the unlock card reads. No wrapped blob is here: the list is read by every client, and the bytes stay behind a release.

vault: Option<VaultWire>

The shared vault session’s lock state and idle bound, for the settings vault card. No token or key is here: the card draws whether the vault is open and when it locks itself.

Trait Implementations

impl<'de> Deserialize<'de> for HomeWire

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for HomeWire

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

where __S: Serializer,

Serialize this value into the given Serde serializer.