Struct ClientSession 

pub struct ClientSession {
    pub client_id: String,
    pub runtime: Arc<Runtime>,
    pub channel: Arc<WsChannel>,
    pub host: Arc<HostState>,
    pub memgine: Arc<Mutex<MemgineEngine>>,
    pub browser: BrowserSessionSlot,
    pub authenticated: AtomicBool,
    pub is_host: AtomicBool,
    pub agent_id: Mutex<Option<String>>,
    pub bound_memgine: Mutex<Option<Arc<Mutex<MemgineEngine>>>>,
    pub current_run_id: Mutex<Option<String>>,
}

Per-client session.

Fields

client_id: String

runtime: Arc<Runtime>

channel: Arc<WsChannel>

host: Arc<HostState>

memgine: Arc<Mutex<MemgineEngine>>

Memgine handle. Wrapped in tokio::sync::Mutex so dispatcher handlers can hold the lock across .await points without risking poisoning. Migrated from std::sync::Mutex in the car-server-core extraction (U1) per the “one-wrapper rule”.

browser: BrowserSessionSlot

Lazy browser session — first browser.run call launches Chromium, subsequent calls reuse it so element IDs resolve across invocations within the same WebSocket connection.

authenticated: AtomicBool

Per-connection auth state. Starts false; flips to true after a successful session.auth handshake. Always considered authenticated when ServerState::auth_token is unset (auth disabled). Closes Parslee-ai/car-releases#32.

is_host: AtomicBool

Host-management role (Parslee-ai/car#254). Starts false; flips to true only when the connection presents the per-launch host token via session.auth { host_token } (validated against ServerState::host_token). authorize_run_access requires this for cross-agent run-trace reads — being merely host.subscribed is no longer sufficient, which is what closes the self-elevation hole. Cleared implicitly when the connection drops.

agent_id: Mutex<Option<String>>

Bound agent identity (#169). Some(id) once a lifecycle-agent child has called session.auth { token, agent_id } and the supervisor confirmed agent_id is supervised + token matches. Used by agents.list to surface which managed agents have actually attached vs. just being marked Running at the process level. Cleared at disconnect by remove_session.

bound_memgine: Mutex<Option<Arc<Mutex<MemgineEngine>>>>

Bound persistent memgine (#170). Some after session.auth successfully attaches the connection to a daemon-owned per-agent memgine (paired with agent_id). Memory handlers route through ClientSession::effective_memgine which returns this when set, falling back to the ephemeral memgine field for browser/host/CLI connections.

current_run_id: Mutex<Option<String>>

The run currently bracketed on this connection (agent run tracing, U1). Set by runs.start before that handler responds, so the per-turn recorder (U2) always reads the run_id the bracket established — no race across the concurrently-spawned dispatch tasks (KTD3). Cleared by runs.complete. On disconnect with a still-set current run and no recorded terminal, the daemon marks it Incomplete (R5).

Implementations

impl ClientSession

pub async fn effective_memgine(&self) -> Arc<Mutex<MemgineEngine>>

Returns the memgine handle the memory.* handlers should use: the bound per-agent memgine when this session attached via session.auth { agent_id } (#169 + #170), otherwise the ephemeral per-WS memgine. Cheap (one async lock + Arc clone).