@team-agent/installer 0.5.115 → 0.5.117

package/crates/team-agent/src/contract_runtime/backend.rs

@@ -317,6 +317,23 @@ fn request(
     })
 }
 
+fn preflight_request(
+    binding: &Binding,
+    role: &RoleConfig,
+    identity: InstanceIdentity,
+    discovered: &Discovery,
+) -> Result<LaunchRequest, BackendError> {
+    let mut request = request(binding, role, identity, discovered)?;
+    if registry::provider(role.provider.as_str())? == registry::NativeProvider::GrokBuild {
+        // Pure H2 only: this is a proposed private path, not a filesystem receipt.
+        request.paths.cwd = team_agent_contract::contract::session::CwdIdentity {
+            path: binding.transport_root.join("workspaces").join(role.id.as_str()),
+            identity: digest(b"effect-free-planned-private-cwd"),
+        };
+    }
+    Ok(request)
+}
+
 /// Team-wide native discovery/admission before the shared launcher creates any
 /// seats (including legacy peers). Bounded read-only native commands run; no
 /// runtime store, worker config, private socket, or worker process is created.
@@ -356,7 +373,7 @@ pub fn preflight(team: &super::config::TeamConfig) -> Result<(), BackendError> {
         };
         let adapter = launch_adapter(&binding, &identity, &role.provider, discovered)?;
         let hooks = adapter.hooks();
-        let request = request(&binding, role, identity, discovered)?;
+        let request = preflight_request(&binding, role, identity, discovered)?;
         let resolved = resolve_launch_preflight(
             selected.descriptor(),
             &hooks,
@@ -404,7 +421,7 @@ pub fn start(
     };
     let probe_adapter = launch_adapter(&provisional, &provisional_identity, &role.provider, &discovered)?;
     let probe_hooks = probe_adapter.hooks();
-    let preflight = request(&provisional, role, provisional_identity, &discovered)?;
+    let preflight = preflight_request(&provisional, role, provisional_identity, &discovered)?;
     let preflight = resolve_launch_preflight(
         descriptor,
         &probe_hooks,
@@ -413,7 +430,6 @@ pub fn start(
     )?;
     let preflight_plan = probe_adapter.plan(&preflight)?;
     validate_launch_plan(descriptor, &preflight, &preflight_plan)?;
-    let server_key = selected.server_key()?;
     let mut backend = if root_for(&cwd.path, &scope).exists() {
         Backend::open(&cwd.path, team)?
     } else {
@@ -446,6 +462,7 @@ pub fn start(
     });
     backend.store.set_framework_routes(&peers, Some(&route))?;
     let identity = backend.store.propose_identity(&role.id)?;
+    let server_key = selected.server_key_for(&identity)?;
     write_role(&backend.binding, &identity, role)?;
     let adapter = launch_adapter(&backend.binding, &identity, &role.provider, &discovered)?;
     let hooks = adapter.hooks();
@@ -453,7 +470,10 @@ pub fn start(
     if !descriptor.workspace.shared_cwd {
         request.paths.cwd = super::workspace::prepare(&backend.binding, &role.id)?;
     }
-    if let Some(runtime) = &discovered.runtime {
+    if selected == registry::NativeProvider::GrokBuild {
+        team_agent_contract::providers::grok_build::native::require_private_primary(&request.paths.cwd)?;
+    }
+    if let Some(registry::NativeRuntime::Cursor(runtime)) = &discovered.runtime {
         request.preassigned_session = Some(
             team_agent_contract::providers::cursor::native::allocate_chat(
                 runtime, &request.paths.cwd, &mut RealCommandRunner::default(),
@@ -484,6 +504,8 @@ pub fn start(
             descriptor,
             hooks: &hooks,
             controls: selected.controls(),
+            startup: selected.startup(),
+            session_panel: selected.session_panel(),
         },
         settings(&backend.binding, selected),
         operation.clone(),
@@ -537,12 +559,20 @@ pub(crate) fn prepare_restart(
     let config = super::framework::team_config(workspace, directory, team)?.ok_or(BackendError::Metadata)?;
     let mut prepared = Vec::new();
     let agents = state.get("agents").and_then(serde_json::Value::as_object).ok_or(BackendError::Metadata)?;
-    for (id, _) in agents.iter().filter(|(_, row)| super::framework::is_contract(row)) {
+    for (id, _) in agents.iter().filter(|(_, row)| {
+        super::framework::is_contract(row)
+            && !crate::state::projection::agent_stopped_for_restart(row)
+    }) {
         let Some(role) = config.roles.iter().find(|role| role.id.as_str() == id) else {
             // Removed roles are not silently re-created from an old snapshot.
             continue;
         };
         if role.paused { continue; }
+        // The native store is authoritative even if its framework mirror is
+        // stale. Only explicit start-agent may resume a stopped generation.
+        let backend = Backend::open_readonly(workspace, team)?;
+        let seat = backend.store.seat(&role.id)?.ok_or(BackendError::Metadata)?;
+        if seat.status == SeatStatus::Stopped { continue; }
         prepared.push(prepare_resume(workspace, team, &role.id, Some(role))?);
     }
     Ok(prepared)
@@ -586,6 +616,9 @@ pub fn prepare_resume(
         binding: source, expected_source: parent.identity,
     });
     let selected = registry::provider(role.provider.as_str())?;
+    if selected == registry::NativeProvider::GrokBuild {
+        team_agent_contract::providers::grok_build::native::require_private_primary(&request.paths.cwd)?;
+    }
     let resolved = resolve_launch(selected.descriptor(), &hooks, &request, Some(&discovered.catalog))?;
     validate_launch_plan(selected.descriptor(), &resolved, &adapter.plan(&resolved)?)?;
     Ok(PreparedResume { binding: backend.binding, role, discovered, request })
@@ -616,7 +649,10 @@ pub fn resume(prepared: PreparedResume) -> Result<OperationRecord, BackendError>
     let mut io = ScopedMaterializer::new(descriptor, &resolved, &plan, operation.clone(), RealCommandRunner::default())?;
     let clock = RealClock::new();
     let mut physical = PhysicalRuntime::new(
-        Registration { descriptor, hooks: &hooks, controls: selected.controls() },
+        Registration {
+            descriptor, hooks: &hooks, controls: selected.controls(),
+            startup: selected.startup(), session_panel: selected.session_panel(),
+        },
         settings(&backend.binding, selected), operation.clone(), &clock,
     )?;
     physical.evidence = policy_evidence(&prepared.role.provider, &prepared.request.native, backend.binding.candidate_sha256)?;
@@ -626,7 +662,7 @@ pub fn resume(prepared: PreparedResume) -> Result<OperationRecord, BackendError>
         Routing {
             pane: "unpublished".into(),
             binding_key: format!("binding-{}", prepared.request.identity.instance.as_str()),
-            server_key: selected.server_key()?.into(),
+            server_key: selected.server_key_for(&prepared.request.identity)?,
         },
         operation,
     )?;
@@ -774,12 +810,15 @@ pub fn stop(workspace: &Path, team: &str, seat: &SeatId) -> Result<OperationReco
         Registration {
             descriptor: selected.descriptor(),
             hooks: &hooks,
-            controls: &[],
+            controls: selected.controls(),
+            startup: selected.startup(),
+            session_panel: selected.session_panel(),
         },
         settings(&backend.binding, selected),
         operation.clone(),
         &clock,
     )?;
+    physical.evidence = policy_evidence(&target.provider, &target.native, backend.binding.candidate_sha256)?;
     Ok(Lifecycle {
         store: &mut backend.store,
         host: &mut physical,
@@ -817,6 +856,47 @@ mod tests {
     }
     impl Drop for RoleFixture { fn drop(&mut self) { let _ = std::fs::remove_dir_all(&self.root); } }
 
+    #[test]
+    fn restart_skips_stopped_mirror_and_stopped_native_store_before_resume_discovery() {
+        for provider in ["cursor", "grok_build"] {
+            let mut fixture = RoleFixture::new();
+            let directory = fixture.root.join("roles");
+            std::fs::create_dir_all(directory.join("agents")).unwrap();
+            std::fs::write(directory.join("TEAM.md"), "---\nname: test\n---\nFixture\n").unwrap();
+            std::fs::write(directory.join("agents/worker.md"),
+                format!("---\nprovider: {provider}\nmodel: unavailable-fixture-model\n---\nFixture\n")).unwrap();
+            let stopped = serde_json::json!({"agents":{"worker":{"provider":provider,"status":"stopped","session_id":"preserved","generation":1}}});
+            // No framework binding/store/native installation exists yet. A
+            // stopped mirror must not even attempt to open the native store.
+            assert!(prepare_restart(&fixture.root, "test", &directory, &stopped).unwrap().is_empty());
+
+            fixture.binding.transport_root = fixture.binding.workspace.path.join("native-store");
+            fixture.binding.endpoint = endpoint(&fixture.binding.scope);
+            let store = ContractStore::create(&fixture.binding.transport_root, fixture.binding.scope.clone(), &fixture.binding.endpoint).unwrap();
+            let native = NativeIdentity { version: "fixture".into(), harness: "unavailable".into(), ui: "tui".into(),
+                platform: Platform::MacOs, executable_sha256: digest(b"fixture") };
+            let seat = SeatRecord {
+                identity: fixture.identity.clone(), provider: ProviderId::new(provider).unwrap(), native,
+                cwd: fixture.binding.workspace.clone(), endpoint: fixture.binding.endpoint.clone(),
+                pane: "unpublished".into(), binding_key: "fixture".into(), profile: "unavailable".into(), server_key: "fixture".into(),
+                evidence_kind: EvidenceKind::Native, status: SeatStatus::Stopped, process: None, physical: None,
+                session: None, resources: vec![], workspace_resources: vec![], bootstrap_used: false,
+            };
+            // Test-only canonical fixture, never a live-store recovery shortcut.
+            let db = rusqlite::Connection::open(fixture.binding.transport_root.join("contract.db")).unwrap();
+            db.execute("INSERT INTO contract_seats(seat,record) VALUES(?1,?2)",
+                rusqlite::params![fixture.identity.seat.as_str(), serde_json::to_string(&seat).unwrap()]).unwrap();
+            db.execute("INSERT INTO contract_generations(seat,generation) VALUES(?1,1)", [fixture.identity.seat.as_str()]).unwrap();
+            drop(db);
+            std::fs::write(root_for(&fixture.binding.workspace.path, &fixture.binding.scope).join("framework-binding.json"),
+                serde_json::to_vec(&fixture.binding).unwrap()).unwrap();
+            let stale_running = serde_json::json!({"agents":{"worker":{"provider":provider,"status":"running"}}});
+            assert!(prepare_restart(&fixture.root, "test", &directory, &stale_running).unwrap().is_empty());
+            assert_eq!(store.seat(&fixture.identity.seat).unwrap(), Some(seat));
+            assert_eq!(store.propose_identity(&fixture.identity.seat).unwrap().generation, Generation(2));
+        }
+    }
+
     #[test]
     fn role_snapshots_are_instance_scoped_and_exclusive() {
         let fixture = RoleFixture::new();

package/crates/team-agent/src/contract_runtime/commands.rs

@@ -51,10 +51,10 @@ fn with_agent(
     apply(&latest, &SeatId::new(agent).map_err(error)?).map(Some)
 }
 
-fn publish(selected: &SelectedTeam, id: &SeatId) -> Result<Value, CliError> {
-    publish_at(&selected.run_workspace, &selected.team_key, id)
+fn publish(selected: &SelectedTeam, id: &SeatId, clear_stop: bool) -> Result<Value, CliError> {
+    publish_at(&selected.run_workspace, &selected.team_key, id, clear_stop)
 }
-fn publish_at(workspace: &Path, team: &str, id: &SeatId) -> Result<Value, CliError> {
+fn publish_at(workspace: &Path, team: &str, id: &SeatId, clear_stop: bool) -> Result<Value, CliError> {
     let projected = framework::project_seat(workspace, team, id.as_str()).map_err(error)?;
     StateRepository::new(workspace).commit(
         StateWriteIntent::StartAgent { team_key: team, agent_id: id.as_str() },
@@ -64,6 +64,9 @@ fn publish_at(workspace: &Path, team: &str, id: &SeatId) -> Result<Value, CliErr
                     row.insert(key.clone(), value.clone());
                 }
                 row.insert("paused".into(), Value::Bool(false));
+                if clear_stop {
+                    row.insert("explicit_stop".into(), Value::Bool(false));
+                }
             }
         },
     ).map_err(error)?;
@@ -79,6 +82,16 @@ fn check_record(receipt: &team_agent_contract::orchestration::store::OperationRe
     Ok(())
 }
 
+// A partial native operation may not have a session for projection yet. Its
+// original receipt must win over any secondary projection/metadata error.
+fn checked_projection(
+    receipt: &team_agent_contract::orchestration::store::OperationRecord,
+    project: impl FnOnce() -> Result<Value, CliError>,
+) -> Result<Value, CliError> {
+    check_record(receipt)?;
+    project()
+}
+
 pub fn start_agent(
     workspace: &Path,
     team: Option<&str>,
@@ -130,8 +143,7 @@ pub fn start_agent(
         };
         // An uncertain operation never rolls the authoritative native store back
         // to the old generation. The receipt remains available for recovery.
-        let projection = publish(selected, id)?;
-        check_record(&receipt)?;
+        let projection = checked_projection(&receipt, || publish(selected, id, true))?;
         let coordinator = crate::coordinator::start_coordinator_with_team(
             &crate::coordinator::WorkspacePath::new(selected.run_workspace.clone()), Some(&selected.team_key),
         ).map_err(error)?;
@@ -162,13 +174,13 @@ pub(crate) fn restart_prepared(
         let session_id = prepared.session().map(str::to_owned);
         let outcome = (|| {
             let receipt = backend::resume(prepared).map_err(error)?;
-            let projection = publish_at(workspace, team, &id)?;
+            let projection = checked_projection(&receipt, || publish_at(workspace, team, &id, false))?;
             if let Some(row) = state.get_mut("agents").and_then(|agents| agents.get_mut(id.as_str())).and_then(Value::as_object_mut) {
                 for (key, value) in projection.as_object().expect("native projection object") {
                     row.insert(key.clone(), value.clone());
                 }
             }
-            check_record(&receipt)
+            Ok::<(), CliError>(())
         })().map_err(|error| error.to_string());
         NativeRestartResult { agent_id: id.as_str().into(), session_id, outcome }
     }).collect()
@@ -235,6 +247,7 @@ pub fn stop_agent(
         for (key, value) in projected.as_object().expect("native projection object") {
             row.insert(key.clone(), value.clone());
         }
+        row.insert("explicit_stop".into(), Value::Bool(true));
         StateRepository::new(&selected.run_workspace).save(
             StateWriteIntent::StopAgent { team_key: &selected.team_key, agent_id: agent }, &state,
         ).map_err(error)?;
@@ -243,3 +256,71 @@ pub fn stop_agent(
             "runtime":"contract","operation":operation}))
     })
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use team_agent_contract::contract::{delivery::DeliveryEffect, session::CwdIdentity, types::*};
+    use team_agent_contract::orchestration::store::{OperationRecord, Phase, SeatRecord, TransactionKind};
+
+    fn receipt(outcome: Outcome) -> OperationRecord {
+        let identity = InstanceIdentity {
+            scope: ScopeId::new("scope").unwrap(), seat: SeatId::new("grok-worker").unwrap(),
+            instance: InstanceId::new("instance-two").unwrap(), generation: Generation(2),
+        };
+        OperationRecord {
+            id: OperationId::new("resume-instance-two").unwrap(), kind: TransactionKind::Restart,
+            target: SeatRecord {
+                identity, provider: ProviderId::new("grok_build").unwrap(),
+                native: NativeIdentity { version: "fixture".into(), harness: "fixture".into(), ui: "tui".into(),
+                    platform: Platform::MacOs, executable_sha256: Digest([0; 32]) },
+                cwd: CwdIdentity { path: "/controlled/native-cwd".into(), identity: Digest([0; 32]) },
+                endpoint: "fixture".into(), pane: "%0".into(), binding_key: "fixture".into(),
+                profile: "fixture".into(), server_key: "fixture".into(), evidence_kind: EvidenceKind::Fixture,
+                status: SeatStatus::Starting, process: None, physical: None, session: None,
+                resources: vec![], workspace_resources: vec![], bootstrap_used: false,
+            },
+            parent: None, phase: Phase::F3Spawn, pending: Some("compensating-stop".into()),
+            resources: vec![], effect: DeliveryEffect::NoEffect, outcome, preserved: vec![],
+            failure: Some("native control SessionInspect guard-deadline".into()),
+        }
+    }
+
+    #[test]
+    fn uncommitted_receipt_precedes_projection_and_preserves_original_failure() {
+        for outcome in [Outcome::Running, Outcome::Compensated, Outcome::NeedsRecovery] {
+            let record = receipt(outcome);
+            let before = record.clone();
+            let mut projected = false;
+            let mut state = json!({"status":"stopped","explicit_stop":true,"generation":1});
+            let original = state.clone();
+            let error = checked_projection(&record, || {
+                projected = true;
+                state["explicit_stop"] = Value::Bool(false);
+                Err(super::error(BackendError::Metadata))
+            }).unwrap_err().to_string();
+            assert!(!projected);
+            assert_eq!(state, original);
+            assert_eq!(record, before);
+            for value in ["resume-instance-two", "F3Spawn", "SessionInspect", "guard-deadline"] {
+                assert!(error.contains(value), "{error}");
+            }
+            assert!(!error.contains("metadata is invalid"), "{error}");
+        }
+    }
+
+    #[test]
+    fn committed_receipt_retains_projection_success_and_error() {
+        let record = receipt(Outcome::Committed);
+        let mut calls = 0;
+        let projected = checked_projection(&record, || {
+            calls += 1;
+            Ok(json!({"status":"running","explicit_stop":false,"generation":2}))
+        }).unwrap();
+        assert_eq!(calls, 1);
+        assert_eq!(projected["explicit_stop"], false);
+        let error = checked_projection(&record, || Err(super::error(BackendError::Metadata)))
+            .unwrap_err().to_string();
+        assert!(error.contains("metadata is invalid"));
+    }
+}

package/crates/team-agent/src/contract_runtime/discovery.rs

@@ -5,9 +5,10 @@ use team_agent_contract::contract::{hooks::*, plan::CatalogObservation, types::*
 use team_agent_contract::host::{command::RealCommandRunner, process::resolve_cwd};
 use team_agent_contract::kiro::native as kiro;
 use team_agent_contract::providers::cursor::native as cursor;
+use team_agent_contract::providers::grok_build::native as grok;
 use thiserror::Error;
 
-use super::registry::{self, NativeProvider};
+use super::registry::{self, NativeProvider, NativeRuntime};
 
 #[derive(Debug, Error)]
 pub enum DiscoveryError {
@@ -19,6 +20,8 @@ pub enum DiscoveryError {
     Probe(#[from] kiro::EngineProbeError),
     #[error("native Cursor launcher probe failed: {0}")]
     CursorProbe(#[from] cursor::ProbeError),
+    #[error("native Grok launcher probe failed: {0}")]
+    GrokProbe(#[from] grok::ProbeError),
     #[error("native discovery contract: {0:?}")]
     Contract(ContractError),
     #[error("native model discovery: {0:?}")]
@@ -31,7 +34,7 @@ pub struct Discovery {
     pub engine: PathBuf,
     pub native: NativeIdentity,
     pub catalog: CatalogObservation,
-    pub runtime: Option<cursor::RuntimeInstallation>,
+    pub runtime: Option<NativeRuntime>,
 }
 
 pub fn executable(name: &'static str) -> Result<PathBuf, DiscoveryError> {
@@ -56,7 +59,13 @@ pub fn discover(provider: &ProviderId, workspace: &Path) -> Result<Discovery, Di
         deadline: std::time::Duration::from_secs(30),
         max_output_bytes: 1024 * 1024,
     };
-    let launcher = executable(descriptor.identity.binary)?;
+    let launcher = if selected == NativeProvider::GrokBuild {
+        // This macOS admission preserves the explicitly approved proxy entry.
+        // PATH may put the inner image first; it must never bypass the wrapper.
+        grok::resolve_launcher(Path::new("/usr/local/bin/grok"))?
+    } else {
+        executable(descriptor.identity.binary)?
+    };
     let (engine, native) = match selected {
         NativeProvider::Kiro => {
             let home = std::env::var_os("HOME")
@@ -71,6 +80,11 @@ pub fn discover(provider: &ProviderId, workspace: &Path) -> Result<Discovery, Di
             let native = cursor::probe_launcher(&engine, &mut RealCommandRunner::default(), bounds)?;
             (engine, native)
         }
+        NativeProvider::GrokBuild => {
+            let engine = grok::resolve_launcher(&launcher)?;
+            let native = grok::probe_launcher(&engine, &mut RealCommandRunner::default(), bounds)?;
+            (engine, native)
+        }
     };
     let request = CatalogRequest {
         provider: ProviderId::new(descriptor.identity.id).map_err(DiscoveryError::Contract)?,
@@ -100,6 +114,11 @@ pub fn discover(provider: &ProviderId, workspace: &Path) -> Result<Discovery, Di
                 .map_err(DiscoveryError::Contract)?;
             catalog_hook.discover(&request, &mut host)
         }
+        NativeProvider::GrokBuild => {
+            let mut host = grok::NativeCatalog::new(request.clone(), RealCommandRunner::default())
+                .map_err(DiscoveryError::Contract)?;
+            catalog_hook.discover(&request, &mut host)
+        }
     }.map_err(DiscoveryError::Catalog)?;
     let result = Discovery { engine, native, catalog, runtime: None };
     validate_catalog(provider, &result).map_err(DiscoveryError::Contract)?;
@@ -110,15 +129,28 @@ pub fn discover(provider: &ProviderId, workspace: &Path) -> Result<Discovery, Di
 /// bridges the same installation's catalog to its proven Node/entry identity.
 pub(super) fn discover_runtime(provider: &ProviderId, workspace: &Path) -> Result<Discovery, DiscoveryError> {
     let mut discovery = discover(provider, workspace)?;
-    if registry::provider(provider.as_str()).map_err(DiscoveryError::Contract)? == NativeProvider::Cursor {
+    let selected = registry::provider(provider.as_str()).map_err(DiscoveryError::Contract)?;
+    if selected != NativeProvider::Kiro {
         let home = std::env::var_os("HOME").map(PathBuf::from)
             .ok_or(DiscoveryError::Executable("HOME for native subscription"))?;
-        let runtime = cursor::probe_runtime(&discovery.engine, &home, &mut RealCommandRunner::default(),
-            ReadBounds { deadline: std::time::Duration::from_secs(30), max_output_bytes: 1024 * 1024 })?;
-        discovery.catalog = runtime.bind_catalog(&discovery.catalog).map_err(DiscoveryError::Contract)?;
-        discovery.engine = runtime.engine.clone();
-        discovery.native = runtime.native.clone();
-        discovery.runtime = Some(runtime);
+        let bounds = ReadBounds { deadline: std::time::Duration::from_secs(30), max_output_bytes: 1024 * 1024 };
+        match selected {
+            NativeProvider::Cursor => {
+                let runtime = cursor::probe_runtime(&discovery.engine, &home, &mut RealCommandRunner::default(), bounds)?;
+                discovery.catalog = runtime.bind_catalog(&discovery.catalog).map_err(DiscoveryError::Contract)?;
+                discovery.engine = runtime.engine.clone();
+                discovery.native = runtime.native.clone();
+                discovery.runtime = Some(NativeRuntime::Cursor(runtime));
+            }
+            NativeProvider::GrokBuild => {
+                let runtime = grok::probe_runtime(&discovery.engine, &home, &mut RealCommandRunner::default(), bounds)?;
+                discovery.catalog = runtime.bind_catalog(&discovery.catalog).map_err(DiscoveryError::Contract)?;
+                discovery.engine = runtime.engine.clone();
+                discovery.native = runtime.native.clone();
+                discovery.runtime = Some(NativeRuntime::GrokBuild(runtime));
+            }
+            NativeProvider::Kiro => unreachable!(),
+        }
     }
     Ok(discovery)
 }

package/crates/team-agent/src/contract_runtime/mcp.rs

@@ -187,6 +187,9 @@ fn run_observed(args: &[String], diagnostics: &mut Diagnostics) -> Result<(), Ba
     };
     diagnostics.fields["scope"] = json!(identity.scope.as_str());
     let seat = diagnostics.step("target_wait", || wait_target(&backend.store, &identity))?;
+    if seat.server_key != super::registry::provider(seat.provider.as_str())?.server_key_for(&identity)? {
+        return Err(Error::Fence.into());
+    }
     let target = seat
         .physical
         .as_ref()

package/crates/team-agent/src/contract_runtime/pump.rs

@@ -148,6 +148,8 @@ fn deliver_one(backend: &mut Backend, seat: &SeatRecord) -> Result<(), BackendEr
             descriptor: selected.descriptor(),
             hooks: &hooks,
             controls: selected.controls(),
+            startup: selected.startup(),
+            session_panel: selected.session_panel(),
         },
         backend::settings(&backend.binding, selected),
         operation.clone(),