From 0869ef0cc6cf7de9c58a54af8c82ea8a4bab1dfb Mon Sep 17 00:00:00 2001
From: Hare <kei.hiracchi.0928@gmail.com>
Date: Tue, 22 Sep 2026 22:26:02 +0900
Subject: [PATCH 1/2] test(e2e): isolate worker server runtime environments

---
 Cargo.lock                               |   2 +
 crates/tui/src/console/mod.rs            |  12 +
 crates/tui/src/lib.rs                    |  73 +-
 crates/worker-runtime/Cargo.toml         |   2 +-
 crates/worker-runtime/src/fs_store.rs    |  64 +-
 crates/worker-runtime/src/http_server.rs |  35 +
 crates/worker-runtime/src/main.rs        |  23 +-
 crates/workspace-server/Cargo.toml       |   2 +-
 crates/workspace-server/src/lib.rs       |   1 +
 crates/workspace-server/src/main.rs      | 191 ++++-
 crates/workspace-server/src/server.rs    |  21 +
 tests/e2e/Cargo.toml                     |   7 +
 tests/e2e/src/lib.rs                     | 217 ++---
 tests/e2e/src/worker_environment.rs      | 978 +++++++++++++++++++++++
 tests/e2e/tests/rewind.rs                |   2 +-
 tests/e2e/tests/worker_environment.rs    |  72 ++
 16 files changed, 1568 insertions(+), 134 deletions(-)
 create mode 100644 tests/e2e/src/worker_environment.rs
 create mode 100644 tests/e2e/tests/worker_environment.rs

diff --git a/Cargo.lock b/Cargo.lock
index 0e9528999..7d941aafb 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -6286,8 +6286,10 @@ name = "yoi-e2e"
 version = "0.0.0"
 dependencies = [
  "libc",
+ "reqwest",
  "serde",
  "serde_json",
+ "sha2 0.11.0",
  "tempfile",
 ]
 
diff --git a/crates/tui/src/console/mod.rs b/crates/tui/src/console/mod.rs
index a3459b7c7..35ea1438e 100644
--- a/crates/tui/src/console/mod.rs
+++ b/crates/tui/src/console/mod.rs
@@ -623,6 +623,16 @@ fn read_terminal_events(stop: Arc<AtomicBool>, tx: mpsc::UnboundedSender<Termina
     }
 }
 
+#[cfg(feature = "e2e-test")]
+pub(crate) async fn run_e2e_rewind(worker_name: String) -> Result<(), Box<dyn std::error::Error>> {
+    let mut terminal = enter_fullscreen()?;
+    let result = run_e2e_rewind_fixture(&mut terminal, worker_name).await;
+    let leave_result = leave_fullscreen(&mut terminal);
+    result?;
+    leave_result?;
+    Ok(())
+}
+
 #[cfg(feature = "e2e-test")]
 async fn run_e2e_rewind_fixture(
     terminal: &mut ConsoleTerminal,
@@ -637,6 +647,8 @@ async fn run_e2e_rewind_fixture(
             entries: Vec::new(),
         },
         state: WorkerStatus::Idle.into(),
+        in_flight: protocol::InFlightSnapshot::default(),
+        internal_workers: Vec::new(),
         greeting: Greeting {
             worker_name: worker_name.clone(),
             cwd: workspace_root.display().to_string(),
diff --git a/crates/tui/src/lib.rs b/crates/tui/src/lib.rs
index 437e554b2..c9c48bd8e 100644
--- a/crates/tui/src/lib.rs
+++ b/crates/tui/src/lib.rs
@@ -137,7 +137,51 @@ pub async fn launch(options: LaunchOptions) -> ExitCode {
     }
     let mut terminal_mode = TerminalModeGuard::new();
 
-    let result = match mode {
+    #[cfg(feature = "e2e-test")]
+    let result = if std::env::var_os("YOI_TUI_TEST_REWIND_FIXTURE").is_some() {
+        let worker_name = match &mode {
+            LaunchMode::Spawn { worker_name, .. } => worker_name
+                .clone()
+                .unwrap_or_else(|| "e2e-rewind".to_string()),
+            _ => "e2e-rewind".to_string(),
+        };
+        console::run_e2e_rewind(worker_name).await
+    } else {
+        launch_mode(target.as_ref(), mode, &workspace_root).await
+    };
+    #[cfg(not(feature = "e2e-test"))]
+    let result = launch_mode(target.as_ref(), mode, &workspace_root).await;
+
+    // Always restore the terminal first so any pending eprintln below
+    // shows up cleanly in scrollback rather than inside an active
+    // alternate-screen buffer.
+    #[cfg(feature = "e2e-test")]
+    e2e_observer::emit("tui", "terminal_cleanup_started", serde_json::json!({}));
+    let _ = terminal_mode.restore();
+    #[cfg(feature = "e2e-test")]
+    e2e_observer::emit("tui", "terminal_cleanup_finished", serde_json::json!({}));
+
+    match result {
+        Ok(()) => {
+            #[cfg(feature = "e2e-test")]
+            e2e_observer::emit("tui", "exit", serde_json::json!({ "status": "success" }));
+            ExitCode::SUCCESS
+        }
+        Err(e) => {
+            eprintln!("yoi: {e}");
+            #[cfg(feature = "e2e-test")]
+            e2e_observer::emit("tui", "exit", serde_json::json!({ "status": "failure" }));
+            ExitCode::FAILURE
+        }
+    }
+}
+
+async fn launch_mode(
+    target: &dyn Target,
+    mode: LaunchMode,
+    workspace_root: &std::path::Path,
+) -> Result<(), Box<dyn std::error::Error>> {
+    match mode {
         LaunchMode::Spawn {
             worker_name,
             profile,
@@ -145,7 +189,7 @@ pub async fn launch(options: LaunchOptions) -> ExitCode {
             Ok(Some(selection)) => match target.spawn_worker() {
                 Ok(spawn) => {
                     console::run_standalone(
-                        workspace_root.clone(),
+                        workspace_root.to_path_buf(),
                         spawn.state_dir,
                         Some(selection.worker_name),
                         Some(selection.profile),
@@ -158,7 +202,7 @@ pub async fn launch(options: LaunchOptions) -> ExitCode {
             Err(error) => Err(Box::new(error) as Box<dyn std::error::Error>),
         },
         LaunchMode::StandaloneResume { include_all } => {
-            match standalone_picker::pick(target.as_ref(), include_all) {
+            match standalone_picker::pick(target, include_all) {
                 Ok(Some(intent)) => console::run_standalone_restore(intent).await,
                 Ok(None) => Ok(()),
                 Err(error) => Err(Box::new(error) as Box<dyn std::error::Error>),
@@ -195,28 +239,5 @@ pub async fn launch(options: LaunchOptions) -> ExitCode {
             }
             Err(e) => Err(Box::new(e) as Box<dyn std::error::Error>),
         },
-    };
-
-    // Always restore the terminal first so any pending eprintln below
-    // shows up cleanly in scrollback rather than inside an active
-    // alternate-screen buffer.
-    #[cfg(feature = "e2e-test")]
-    e2e_observer::emit("tui", "terminal_cleanup_started", serde_json::json!({}));
-    let _ = terminal_mode.restore();
-    #[cfg(feature = "e2e-test")]
-    e2e_observer::emit("tui", "terminal_cleanup_finished", serde_json::json!({}));
-
-    match result {
-        Ok(()) => {
-            #[cfg(feature = "e2e-test")]
-            e2e_observer::emit("tui", "exit", serde_json::json!({ "status": "success" }));
-            ExitCode::SUCCESS
-        }
-        Err(e) => {
-            eprintln!("yoi: {e}");
-            #[cfg(feature = "e2e-test")]
-            e2e_observer::emit("tui", "exit", serde_json::json!({ "status": "failure" }));
-            ExitCode::FAILURE
-        }
     }
 }
diff --git a/crates/worker-runtime/Cargo.toml b/crates/worker-runtime/Cargo.toml
index e07dde7ef..3f4a327c3 100644
--- a/crates/worker-runtime/Cargo.toml
+++ b/crates/worker-runtime/Cargo.toml
@@ -41,7 +41,7 @@ reqwest = { version = "0.13", optional = true, default-features = false, feature
 ring.workspace = true
 tar.workspace = true
 thiserror = { workspace = true }
-tokio = { workspace = true, features = ["net", "process", "rt", "sync", "time"] }
+tokio = { workspace = true, features = ["net", "process", "rt", "signal", "sync", "time"] }
 tracing.workspace = true
 tracing-subscriber.workspace = true
 toml.workspace = true
diff --git a/crates/worker-runtime/src/fs_store.rs b/crates/worker-runtime/src/fs_store.rs
index ffb129bfa..731d97113 100644
--- a/crates/worker-runtime/src/fs_store.rs
+++ b/crates/worker-runtime/src/fs_store.rs
@@ -123,8 +123,8 @@ impl FsRuntimeStore {
         })?;
         let owner_lock = acquire_runtime_store_owner_lock(&root)?;
         recover_runtime_store_migration(&root)?;
-        let existed = root.exists();
-        if existed && !root.is_dir() {
+        let root_existed = root.exists();
+        if root_existed && !root.is_dir() {
             return Err(RuntimeError::StoreCorrupt {
                 operation: "open runtime store",
                 path: root,
@@ -132,17 +132,36 @@ impl FsRuntimeStore {
             });
         }
 
-        if !existed {
+        if !root_existed {
             fs::create_dir_all(&root).map_err(|source| RuntimeError::StoreIo {
                 operation: "create runtime store root",
                 path: root.clone(),
                 source,
             })?;
         }
+        let snapshot_exists = root.join(RUNTIME_FILE).is_file();
+        let workers_dir = root.join(WORKERS_DIR);
+        if !snapshot_exists
+            && workers_dir.is_dir()
+            && fs::read_dir(&workers_dir)
+                .map_err(|source| RuntimeError::StoreIo {
+                    operation: "inspect uninitialized runtime store",
+                    path: workers_dir.clone(),
+                    source,
+                })?
+                .next()
+                .is_some()
+        {
+            return Err(RuntimeError::StoreCorrupt {
+                operation: "open runtime store",
+                path: root,
+                message: "Worker records exist without a Runtime snapshot".to_string(),
+            });
+        }
 
-        fs::create_dir_all(root.join(WORKERS_DIR)).map_err(|source| RuntimeError::StoreIo {
+        fs::create_dir_all(&workers_dir).map_err(|source| RuntimeError::StoreIo {
             operation: "create runtime store",
-            path: root.join(WORKERS_DIR),
+            path: workers_dir,
             source,
         })?;
         let legacy_events = root.join("events.jsonl");
@@ -158,14 +177,14 @@ impl FsRuntimeStore {
             }
         }
 
-        if existed {
+        if snapshot_exists {
             migrate_runtime_store(&root, runtime_id)?;
         }
         let store = Self {
             root,
             _owner_lock: Some(owner_lock),
         };
-        let state = if existed {
+        let state = if snapshot_exists {
             Some(store.load_runtime_state()?)
         } else {
             None
@@ -2137,6 +2156,37 @@ mod tests {
         document["schema_version"].as_u64().unwrap()
     }
 
+    #[test]
+    fn auth_initialized_directory_without_snapshot_is_a_fresh_store() {
+        let parent = tempfile::tempdir().unwrap();
+        let root = parent.path().join("runtime");
+        fs::create_dir_all(&root).unwrap();
+        fs::write(root.join("auth.toml"), b"fixture auth material").unwrap();
+
+        let opened = FsRuntimeStore::open_or_create(root.clone(), "runtime-test").unwrap();
+
+        assert!(opened.state.is_none());
+        assert!(root.join(WORKERS_DIR).is_dir());
+        assert_eq!(
+            fs::read(root.join("auth.toml")).unwrap(),
+            b"fixture auth material"
+        );
+    }
+
+    #[test]
+    fn worker_records_without_runtime_snapshot_are_rejected() {
+        let parent = tempfile::tempdir().unwrap();
+        let root = parent.path().join("runtime");
+        fs::create_dir_all(root.join(WORKERS_DIR).join("orphan")).unwrap();
+
+        let error = FsRuntimeStore::open_or_create(root.clone(), "runtime-test").unwrap_err();
+
+        assert!(matches!(
+            error,
+            RuntimeError::StoreCorrupt { path, .. } if path == root
+        ));
+    }
+
     #[test]
     fn runtime_store_owner_lock_child_probe() {
         let Some(root) = std::env::var_os("YOI_TEST_RUNTIME_STORE_LOCK_ROOT") else {
diff --git a/crates/worker-runtime/src/http_server.rs b/crates/worker-runtime/src/http_server.rs
index 5462a09f5..1ffdae919 100644
--- a/crates/worker-runtime/src/http_server.rs
+++ b/crates/worker-runtime/src/http_server.rs
@@ -139,6 +139,22 @@ pub enum RuntimeHttpStoreSelection {
     },
 }
 
+pub async fn serve_runtime_http_with_shutdown<F>(
+    runtime: Runtime,
+    listener: TcpListener,
+    local_token: Option<String>,
+    shutdown: F,
+) -> Result<(), RuntimeHttpServerError>
+where
+    F: std::future::Future<Output = ()> + Send + 'static,
+{
+    let local_token = local_token.ok_or(RuntimeHttpServerError::AuthRequired)?;
+    axum::serve(listener, runtime_http_router(runtime, local_token))
+        .with_graceful_shutdown(shutdown)
+        .await?;
+    Ok(())
+}
+
 /// Serve an existing Runtime on a pre-bound listener.
 pub async fn serve_runtime_http(
     runtime: Runtime,
@@ -150,6 +166,25 @@ pub async fn serve_runtime_http(
     Ok(())
 }
 
+pub async fn serve_runtime_http_with_workspace_auth_shutdown<F>(
+    runtime: Runtime,
+    listener: TcpListener,
+    local_token: Option<String>,
+    workspace_auth: WorkspaceRuntimeHttpAuth,
+    shutdown: F,
+) -> Result<(), RuntimeHttpServerError>
+where
+    F: std::future::Future<Output = ()> + Send + 'static,
+{
+    axum::serve(
+        listener,
+        runtime_http_router_with_optional_auth(runtime, local_token, Some(workspace_auth)),
+    )
+    .with_graceful_shutdown(shutdown)
+    .await?;
+    Ok(())
+}
+
 pub async fn serve_runtime_http_with_workspace_auth(
     runtime: Runtime,
     listener: TcpListener,
diff --git a/crates/worker-runtime/src/main.rs b/crates/worker-runtime/src/main.rs
index 835efde8b..c09b0f149 100644
--- a/crates/worker-runtime/src/main.rs
+++ b/crates/worker-runtime/src/main.rs
@@ -75,6 +75,23 @@ fn init_serve_tracing() {
         .try_init();
 }
 
+async fn shutdown_signal() {
+    #[cfg(unix)]
+    {
+        let mut terminate =
+            tokio::signal::unix::signal(tokio::signal::unix::SignalKind::terminate())
+                .expect("install SIGTERM handler");
+        tokio::select! {
+            _ = tokio::signal::ctrl_c() => {},
+            _ = terminate.recv() => {},
+        }
+    }
+    #[cfg(not(unix))]
+    {
+        let _ = tokio::signal::ctrl_c().await;
+    }
+}
+
 fn run() -> Result<(), ProcessError> {
     let args = env::args().skip(1).collect::<Vec<_>>();
     if matches!(args.first().map(String::as_str), Some("migrate")) {
@@ -104,11 +121,12 @@ fn run() -> Result<(), ProcessError> {
             "yoi-runtime listening on {local_addr}; intended client is a trusted backend/proxy, not a browser"
         );
         let server = if let Some(workspace_auth) = workspace_http_auth {
-            worker_runtime::http_server::serve_runtime_http_with_workspace_auth(
+            worker_runtime::http_server::serve_runtime_http_with_workspace_auth_shutdown(
                 worker_runtime,
                 listener,
                 config.http.local_token,
                 workspace_auth,
+                shutdown_signal(),
             )
             .await
         } else {
@@ -117,10 +135,11 @@ fn run() -> Result<(), ProcessError> {
                     "Runtime HTTP server requires Workspace issuer auth or --local-token".to_owned(),
                 )
             })?;
-            worker_runtime::http_server::serve_runtime_http(
+            worker_runtime::http_server::serve_runtime_http_with_shutdown(
                 worker_runtime,
                 listener,
                 Some(local_token),
+                shutdown_signal(),
             )
             .await
         };
diff --git a/crates/workspace-server/Cargo.toml b/crates/workspace-server/Cargo.toml
index 39b41e9c4..5b7330acc 100644
--- a/crates/workspace-server/Cargo.toml
+++ b/crates/workspace-server/Cargo.toml
@@ -38,7 +38,7 @@ thiserror.workspace = true
 ticket.workspace = true
 memory.workspace = true
 merge-request.workspace = true
-tokio = { workspace = true, features = ["fs", "macros", "net", "rt-multi-thread", "sync", "time"] }
+tokio = { workspace = true, features = ["fs", "macros", "net", "rt-multi-thread", "signal", "sync", "time"] }
 tower.workspace = true
 tokio-tungstenite = { workspace = true, features = ["rustls-tls-webpki-roots"] }
 worker.workspace = true
diff --git a/crates/workspace-server/src/lib.rs b/crates/workspace-server/src/lib.rs
index a1ebc50e5..efab8ecbb 100644
--- a/crates/workspace-server/src/lib.rs
+++ b/crates/workspace-server/src/lib.rs
@@ -48,6 +48,7 @@ pub use repositories::{ConfiguredRepository, RepositoryLogRead, RepositoryRegist
 pub use server::{
     AuthConfig, ServerConfig, WorkspaceApi, WorkspaceServerApi, build_router,
     build_workspace_server_router, serve, serve_workspace_catalog,
+    serve_workspace_catalog_with_shutdown,
 };
 pub use server_api::{
     GitCommitSummary, GitRemoteSummary, GitRepositorySummary, RepositorySummary,
diff --git a/crates/workspace-server/src/main.rs b/crates/workspace-server/src/main.rs
index 08a3d9c36..b712941e8 100644
--- a/crates/workspace-server/src/main.rs
+++ b/crates/workspace-server/src/main.rs
@@ -9,18 +9,19 @@ use yoi_workspace_server::hosts::{
     EMBEDDED_RUNTIME_ID, RemoteRuntimeConfig, is_loopback_runtime_origin,
 };
 use yoi_workspace_server::store::{
-    SqliteWorkspaceStore, WorkspaceRuntimeAuthenticationMode, WorkspaceRuntimeBinding,
-    WorkspaceRuntimeBindingState,
+    AccountRecord, ApiTokenRecord, SqliteWorkspaceStore, UserRecord,
+    WorkspaceRuntimeAuthenticationMode, WorkspaceRuntimeBinding, WorkspaceRuntimeBindingState,
 };
 use yoi_workspace_server::{
     ControlPlaneStore, ResolvedWorkspaceBackendConfig, ServerConfig, ServerHostConfigFile,
-    WorkspaceRecord, serve_workspace_catalog,
+    WorkspaceRecord, serve_workspace_catalog_with_shutdown,
 };
 
 #[derive(Debug)]
 enum Command {
     Serve(ServeOptions),
     Migrate(MigrateOptions),
+    BootstrapAuth(BootstrapAuthOptions),
     Skills(SkillsCommand),
     Help,
 }
@@ -38,6 +39,13 @@ struct MigrateOptions {
     help: bool,
 }
 
+#[derive(Debug)]
+struct BootstrapAuthOptions {
+    handle: String,
+    display_name: Option<String>,
+    label: Option<String>,
+}
+
 #[derive(Debug)]
 struct SkillWorkspaceOptions {
     workspace_id: String,
@@ -77,6 +85,7 @@ async fn run() -> Result<(), Box<dyn std::error::Error>> {
     match parse_command(&args)? {
         Command::Serve(options) => run_serve(options).await,
         Command::Migrate(options) => run_migrate(options),
+        Command::BootstrapAuth(options) => run_bootstrap_auth(options),
         Command::Skills(command) => run_skills(command),
         Command::Help => Ok(()),
     }
@@ -90,6 +99,7 @@ fn parse_command(args: &[String]) -> Result<Command, CliError> {
 
     match command.as_str() {
         "migrate" => parse_migrate_options(rest).map(Command::Migrate),
+        "bootstrap-auth" => parse_bootstrap_auth_options(rest).map(Command::BootstrapAuth),
         "skills" => parse_skills_command(rest),
         "serve" => {
             if rest.iter().any(|arg| arg == "--help" || arg == "-h") {
@@ -103,7 +113,7 @@ fn parse_command(args: &[String]) -> Result<Command, CliError> {
             Ok(Command::Help)
         }
         other => Err(CliError(format!(
-            "unknown command `{other}`; expected `migrate`, `skills`, or `serve`"
+            "unknown command `{other}`; expected `bootstrap-auth`, `migrate`, `skills`, or `serve`"
         ))),
     }
 }
@@ -214,6 +224,131 @@ fn run_migrate(options: MigrateOptions) -> Result<(), Box<dyn std::error::Error>
     Ok(())
 }
 
+fn run_bootstrap_auth(options: BootstrapAuthOptions) -> Result<(), Box<dyn std::error::Error>> {
+    let database_path = ServerConfig::default_server_database_path();
+    if let Some(parent) = database_path.parent() {
+        std::fs::create_dir_all(parent)?;
+    }
+    let store = SqliteWorkspaceStore::open(&database_path)?;
+    if !store.list_workspaces()?.is_empty() {
+        return Err(Box::new(CliError(
+            "bootstrap-auth is available only before the first Workspace is created".to_string(),
+        )));
+    }
+
+    let handle = yoi_workspace_server::auth::normalize_handle(&options.handle)?;
+    let display_name = options
+        .display_name
+        .as_deref()
+        .map(str::trim)
+        .filter(|value| !value.is_empty())
+        .unwrap_or(&handle)
+        .to_string();
+    let now = yoi_workspace_server::auth::now_rfc3339();
+    let user = match store.any_user()? {
+        Some(user) if user.handle == handle => user,
+        Some(_) => {
+            return Err(Box::new(CliError(
+                "bootstrap-auth refuses to replace an existing bootstrap user".to_string(),
+            )));
+        }
+        None => {
+            let account_id = yoi_workspace_server::auth::new_id("acct-user");
+            store.upsert_account(&AccountRecord {
+                account_id: account_id.clone(),
+                kind: "user".to_string(),
+                handle: handle.clone(),
+                display_name: display_name.clone(),
+                created_at: now.clone(),
+                updated_at: now.clone(),
+            })?;
+            let user = UserRecord {
+                user_id: yoi_workspace_server::auth::new_id("user"),
+                account_id,
+                handle,
+                display_name,
+                created_at: now.clone(),
+                updated_at: now.clone(),
+            };
+            store.upsert_user(&user)?;
+            user
+        }
+    };
+
+    let access_token = yoi_workspace_server::auth::mint_secret("yoi_api");
+    store.create_api_token(&ApiTokenRecord {
+        token_id: yoi_workspace_server::auth::new_id("api-token"),
+        token_hash: yoi_workspace_server::auth::token_hash(&access_token),
+        user_id: user.user_id.clone(),
+        label: options
+            .label
+            .unwrap_or_else(|| "initial host setup".to_string()),
+        created_at: now,
+        expires_at: None,
+        revoked_at: None,
+        last_used_at: None,
+    })?;
+    println!(
+        "{}",
+        serde_json::to_string(&serde_json::json!({
+            "access_token": access_token,
+            "token_type": "bearer",
+            "user": {
+                "user_id": user.user_id,
+                "account_id": user.account_id,
+                "handle": user.handle,
+                "display_name": user.display_name,
+            }
+        }))?
+    );
+    Ok(())
+}
+
+fn parse_bootstrap_auth_options(args: &[String]) -> Result<BootstrapAuthOptions, CliError> {
+    let mut handle = None;
+    let mut display_name = None;
+    let mut label = None;
+    let mut index = 0;
+    while index < args.len() {
+        let arg = &args[index];
+        let (field, target) = match arg.as_str() {
+            "--handle" => ("--handle", &mut handle),
+            "--display-name" => ("--display-name", &mut display_name),
+            "--label" => ("--label", &mut label),
+            _ if arg.starts_with("--handle=") => {
+                handle = Some(value_after_equals(arg, "--handle")?.to_string());
+                index += 1;
+                continue;
+            }
+            _ if arg.starts_with("--display-name=") => {
+                display_name = Some(value_after_equals(arg, "--display-name")?.to_string());
+                index += 1;
+                continue;
+            }
+            _ if arg.starts_with("--label=") => {
+                label = Some(value_after_equals(arg, "--label")?.to_string());
+                index += 1;
+                continue;
+            }
+            other => return Err(CliError(format!("unknown bootstrap-auth option `{other}`"))),
+        };
+        index += 1;
+        let value = args
+            .get(index)
+            .ok_or_else(|| CliError(format!("{field} requires a value")))?;
+        if target.replace(value.clone()).is_some() {
+            return Err(CliError(format!("{field} must be provided only once")));
+        }
+        index += 1;
+    }
+    let handle = handle.ok_or_else(|| CliError("bootstrap-auth requires --handle".to_string()))?;
+    Ok(BootstrapAuthOptions {
+        handle,
+        display_name,
+        label,
+    })
+}
+
 fn init_serve_tracing() {
     let filter = tracing_subscriber::EnvFilter::try_from_default_env()
         .unwrap_or_else(|_| tracing_subscriber::EnvFilter::new("info"));
@@ -226,6 +361,23 @@ fn init_serve_tracing() {
         .try_init();
 }
 
+async fn shutdown_signal() {
+    #[cfg(unix)]
+    {
+        let mut terminate =
+            tokio::signal::unix::signal(tokio::signal::unix::SignalKind::terminate())
+                .expect("install SIGTERM handler");
+        tokio::select! {
+            _ = tokio::signal::ctrl_c() => {},
+            _ = terminate.recv() => {},
+        }
+    }
+    #[cfg(not(unix))]
+    {
+        let _ = tokio::signal::ctrl_c().await;
+    }
+}
+
 async fn run_serve(options: ServeOptions) -> Result<(), Box<dyn std::error::Error>> {
     init_serve_tracing();
     let database_path = ServerConfig::default_server_database_path();
@@ -284,7 +436,8 @@ async fn run_serve(options: ServeOptions) -> Result<(), Box<dyn std::error::Erro
         database_path.display(),
         local_addr
     );
-    serve_workspace_catalog(resolved.server, store, listener).await?;
+    serve_workspace_catalog_with_shutdown(resolved.server, store, listener, shutdown_signal())
+        .await?;
     Ok(())
 }
 
@@ -490,7 +643,7 @@ fn parse_listen(value: &str) -> Result<SocketAddr, CliError> {
 
 fn print_help() {
     println!(
-        "yoi-server\n\nUsage:\n  yoi-server migrate [--dry-run] [--database <PATH>]\n  yoi-server skills <COMMAND> [OPTIONS]\n  yoi-server serve [OPTIONS]\n\nOptions:\n  -h, --help    Print help"
+        "yoi-server\n\nUsage:\n  yoi-server bootstrap-auth --handle <HANDLE> [--display-name <NAME>] [--label <LABEL>]\n  yoi-server migrate [--dry-run] [--database <PATH>]\n  yoi-server skills <COMMAND> [OPTIONS]\n  yoi-server serve [OPTIONS]\n\nOptions:\n  -h, --help    Print help"
     );
 }
 
@@ -527,6 +680,28 @@ mod tests {
         }
     }
 
+    #[test]
+    fn parse_bootstrap_auth_requires_handle_and_accepts_host_setup_fields() {
+        let command = parse_command(&[
+            "bootstrap-auth".to_string(),
+            "--handle=e2e-owner".to_string(),
+            "--display-name".to_string(),
+            "E2E Owner".to_string(),
+            "--label".to_string(),
+            "e2e setup".to_string(),
+        ])
+        .unwrap();
+        let Command::BootstrapAuth(options) = command else {
+            panic!("expected bootstrap-auth command");
+        };
+        assert_eq!(options.handle, "e2e-owner");
+        assert_eq!(options.display_name.as_deref(), Some("E2E Owner"));
+        assert_eq!(options.label.as_deref(), Some("e2e setup"));
+
+        let error = parse_bootstrap_auth_options(&[]).unwrap_err();
+        assert_eq!(error.to_string(), "bootstrap-auth requires --handle");
+    }
+
     #[test]
     fn parse_migrate_uses_the_shared_schema_path() {
         let command = parse_command(&[
@@ -662,7 +837,9 @@ mod tests {
             let error = parse_command(&[command.to_owned()]).unwrap_err();
             assert_eq!(
                 error.to_string(),
-                format!("unknown command `{command}`; expected `migrate`, `skills`, or `serve`")
+                format!(
+                    "unknown command `{command}`; expected `bootstrap-auth`, `migrate`, `skills`, or `serve`"
+                )
             );
         }
     }
diff --git a/crates/workspace-server/src/server.rs b/crates/workspace-server/src/server.rs
index 12090b437..95af16ff7 100644
--- a/crates/workspace-server/src/server.rs
+++ b/crates/workspace-server/src/server.rs
@@ -1995,6 +1995,10 @@ struct WorkspaceListQuery {
     limit: Option<usize>,
 }
 
+async fn server_health() -> Json<serde_json::Value> {
+    Json(serde_json::json!({ "status": "ok" }))
+}
+
 async fn list_server_workspaces(
     State(api): State<WorkspaceServerApi>,
     headers: HeaderMap,
@@ -2663,6 +2667,7 @@ pub async fn build_workspace_server_router(
     api.preload().await?;
     api.recover_workspace_deletions().await?;
     let catalog = Router::new()
+        .route("/health", get(server_health))
         .route(
             "/api/workspaces",
             get(list_server_workspaces).post(create_server_workspace),
@@ -4565,6 +4570,22 @@ struct ApiFailureLogEvent<'a> {
     diagnostics: Option<&'a [RuntimeDiagnostic]>,
 }
 
+pub async fn serve_workspace_catalog_with_shutdown<F>(
+    template: ServerConfig,
+    store: Arc<dyn ControlPlaneStore>,
+    listener: TcpListener,
+    shutdown: F,
+) -> Result<()>
+where
+    F: std::future::Future<Output = ()> + Send + 'static,
+{
+    let router = build_workspace_server_router(template, store).await?;
+    axum::serve(listener, router)
+        .with_graceful_shutdown(shutdown)
+        .await?;
+    Ok(())
+}
+
 pub async fn serve_workspace_catalog(
     template: ServerConfig,
     store: Arc<dyn ControlPlaneStore>,
diff --git a/tests/e2e/Cargo.toml b/tests/e2e/Cargo.toml
index 11b85a16b..cdba03914 100644
--- a/tests/e2e/Cargo.toml
+++ b/tests/e2e/Cargo.toml
@@ -12,8 +12,10 @@ e2e = []
 
 [dependencies]
 libc.workspace = true
+reqwest = { version = "0.13", default-features = false, features = ["blocking", "json", "rustls"] }
 serde = { workspace = true, features = ["derive"] }
 serde_json.workspace = true
+sha2.workspace = true
 tempfile.workspace = true
 
 [[test]]
@@ -25,3 +27,8 @@ required-features = ["e2e"]
 name = "rewind"
 path = "tests/rewind.rs"
 required-features = ["e2e"]
+
+[[test]]
+name = "worker_environment"
+path = "tests/worker_environment.rs"
+required-features = ["e2e"]
diff --git a/tests/e2e/src/lib.rs b/tests/e2e/src/lib.rs
index c07fba014..c8e5ff568 100644
--- a/tests/e2e/src/lib.rs
+++ b/tests/e2e/src/lib.rs
@@ -1267,6 +1267,65 @@ impl Drop for PanelHarness {
     }
 }
 
+mod worker_environment;
+
+pub use worker_environment::{
+    WorkerBinaryProviderInfo, WorkerE2eEnvironment, WorkerEnvironmentCleanupReport,
+    worker_binary_provider_info,
+};
+
+#[derive(Debug)]
+struct FixtureAllocation {
+    temp_root: TempDir,
+    root: PathBuf,
+    home: PathBuf,
+    xdg_data_home: PathBuf,
+    xdg_state_home: PathBuf,
+    xdg_config_home: PathBuf,
+    xdg_runtime_dir: PathBuf,
+    artifacts_dir: PathBuf,
+}
+
+fn allocate_fixture(kind: &str) -> Result<FixtureAllocation> {
+    let workspace_root = workspace_root()?;
+    let target_dir = workspace_root.join("target");
+    let temp_parent = target_dir.join("e2e-tmp");
+    let artifact_parent = target_dir.join("e2e-artifacts");
+    fs::create_dir_all(&temp_parent)?;
+    fs::create_dir_all(&artifact_parent)?;
+    let fixture_id = format!(
+        "{kind}-{}-{}-{}",
+        std::process::id(),
+        now_ms(),
+        FIXTURE_COUNTER.fetch_add(1, Ordering::Relaxed)
+    );
+    let temp_root = tempfile::Builder::new()
+        .prefix(&format!("yoi-e2e-{fixture_id}-"))
+        .tempdir_in(&temp_parent)?;
+    let root = temp_root.path().to_path_buf();
+    let allocation = FixtureAllocation {
+        temp_root,
+        home: root.join("home"),
+        xdg_data_home: root.join("data"),
+        xdg_state_home: root.join("state"),
+        xdg_config_home: root.join("config"),
+        xdg_runtime_dir: root.join("run"),
+        artifacts_dir: artifact_parent.join(fixture_id),
+        root,
+    };
+    for dir in [
+        &allocation.home,
+        &allocation.xdg_data_home,
+        &allocation.xdg_state_home,
+        &allocation.xdg_config_home,
+        &allocation.xdg_runtime_dir,
+        &allocation.artifacts_dir,
+    ] {
+        fs::create_dir_all(dir)?;
+    }
+    Ok(allocation)
+}
+
 #[derive(Debug, Clone, Serialize)]
 pub struct FixtureCleanupReport {
     pub fixture_root: PathBuf,
@@ -1299,107 +1358,87 @@ pub struct FixtureWorkspace {
 
 impl FixtureWorkspace {
     pub fn new(binary: &Path) -> Result<Self> {
-        let workspace_root = workspace_root()?;
-        let target_dir = workspace_root.join("target");
-        let temp_parent = target_dir.join("e2e-tmp");
-        let artifact_parent = target_dir.join("e2e-artifacts");
-        fs::create_dir_all(&temp_parent)?;
-        fs::create_dir_all(&artifact_parent)?;
+        Self::new_inner(binary, true)
+    }
 
-        let fixture_id = format!(
-            "{}-{}-{}",
-            std::process::id(),
-            now_ms(),
-            FIXTURE_COUNTER.fetch_add(1, Ordering::Relaxed)
-        );
-        let temp_root = tempfile::Builder::new()
-            .prefix(&format!("yoi-e2e-{fixture_id}-"))
-            .tempdir_in(&temp_parent)?;
-        let root = temp_root.path().to_path_buf();
-        let artifacts_dir = artifact_parent.join(fixture_id);
+    pub fn new_rewind(binary: &Path) -> Result<Self> {
+        Self::new_inner(binary, false)
+    }
+
+    fn new_inner(binary: &Path, setup_dashboard: bool) -> Result<Self> {
+        let allocation = allocate_fixture("tui")?;
+        let root = allocation.root;
+        let artifacts_dir = allocation.artifacts_dir;
         let workspace = root.join("workspace");
-        let home = root.join("home");
-        let xdg_data_home = root.join("data");
-        let xdg_state_home = root.join("state");
-        let xdg_config_home = root.join("config");
-        let xdg_runtime_dir = root.join("runtime");
-        for dir in [
-            &workspace,
-            &home,
-            &xdg_data_home,
-            &xdg_state_home,
-            &xdg_config_home,
-            &xdg_runtime_dir,
-            &artifacts_dir,
-        ] {
-            fs::create_dir_all(dir)?;
-        }
+        fs::create_dir_all(&workspace)?;
 
         let mut fixture = Self {
-            temp_root: Some(temp_root),
+            temp_root: Some(allocation.temp_root),
             root,
             workspace,
-            home,
-            xdg_data_home,
-            xdg_state_home,
-            xdg_config_home,
-            xdg_runtime_dir,
+            home: allocation.home,
+            xdg_data_home: allocation.xdg_data_home,
+            xdg_state_home: allocation.xdg_state_home,
+            xdg_config_home: allocation.xdg_config_home,
+            xdg_runtime_dir: allocation.xdg_runtime_dir,
             artifacts_dir,
             ready_ticket_id: String::new(),
             planning_ticket_id: String::new(),
         };
         fixture.write_fixture_metadata("created", None)?;
 
-        let worker_metadata_root = active_worker_metadata_root(&fixture.home);
-        write_blocking_worker_metadata(&worker_metadata_root, "workspace")?;
-        write_blocking_worker_metadata(&worker_metadata_root, "workspace-orchestrator")?;
-        run_yoi(
-            binary,
-            &fixture.workspace,
-            &fixture.home,
-            &fixture.xdg_data_home,
-            &fixture.xdg_state_home,
-            &fixture.xdg_config_home,
-            &fixture.xdg_runtime_dir,
-            &fixture.artifacts_dir,
-            &["ticket", "init"],
-        )?;
-        let first = create_ticket(
-            binary,
-            &fixture.workspace,
-            &fixture.home,
-            &fixture.xdg_data_home,
-            &fixture.xdg_state_home,
-            &fixture.xdg_config_home,
-            &fixture.xdg_runtime_dir,
-            &fixture.artifacts_dir,
-            READY_FIXTURE_TICKET_TITLE,
-        )?;
-        run_yoi(
-            binary,
-            &fixture.workspace,
-            &fixture.home,
-            &fixture.xdg_data_home,
-            &fixture.xdg_state_home,
-            &fixture.xdg_config_home,
-            &fixture.xdg_runtime_dir,
-            &fixture.artifacts_dir,
-            &["ticket", "state", &first, "ready"],
-        )?;
-        let second = create_ticket(
-            binary,
-            &fixture.workspace,
-            &fixture.home,
-            &fixture.xdg_data_home,
-            &fixture.xdg_state_home,
-            &fixture.xdg_config_home,
-            &fixture.xdg_runtime_dir,
-            &fixture.artifacts_dir,
-            PLANNING_FIXTURE_TICKET_TITLE,
-        )?;
-        fixture.ready_ticket_id = first;
-        fixture.planning_ticket_id = second;
-        fixture.setup_orchestration_overlay(binary)?;
+        if setup_dashboard {
+            let worker_metadata_root = active_worker_metadata_root(&fixture.home);
+            write_blocking_worker_metadata(&worker_metadata_root, "workspace")?;
+            write_blocking_worker_metadata(&worker_metadata_root, "workspace-orchestrator")?;
+            run_yoi(
+                binary,
+                &fixture.workspace,
+                &fixture.home,
+                &fixture.xdg_data_home,
+                &fixture.xdg_state_home,
+                &fixture.xdg_config_home,
+                &fixture.xdg_runtime_dir,
+                &fixture.artifacts_dir,
+                &["ticket", "init"],
+            )?;
+            let first = create_ticket(
+                binary,
+                &fixture.workspace,
+                &fixture.home,
+                &fixture.xdg_data_home,
+                &fixture.xdg_state_home,
+                &fixture.xdg_config_home,
+                &fixture.xdg_runtime_dir,
+                &fixture.artifacts_dir,
+                READY_FIXTURE_TICKET_TITLE,
+            )?;
+            run_yoi(
+                binary,
+                &fixture.workspace,
+                &fixture.home,
+                &fixture.xdg_data_home,
+                &fixture.xdg_state_home,
+                &fixture.xdg_config_home,
+                &fixture.xdg_runtime_dir,
+                &fixture.artifacts_dir,
+                &["ticket", "state", &first, "ready"],
+            )?;
+            let second = create_ticket(
+                binary,
+                &fixture.workspace,
+                &fixture.home,
+                &fixture.xdg_data_home,
+                &fixture.xdg_state_home,
+                &fixture.xdg_config_home,
+                &fixture.xdg_runtime_dir,
+                &fixture.artifacts_dir,
+                PLANNING_FIXTURE_TICKET_TITLE,
+            )?;
+            fixture.ready_ticket_id = first;
+            fixture.planning_ticket_id = second;
+            fixture.setup_orchestration_overlay(binary)?;
+        }
         fixture.write_fixture_metadata("ready", None)?;
         Ok(fixture)
     }
diff --git a/tests/e2e/src/worker_environment.rs b/tests/e2e/src/worker_environment.rs
new file mode 100644
index 000000000..fb92b1fbb
--- /dev/null
+++ b/tests/e2e/src/worker_environment.rs
@@ -0,0 +1,978 @@
+use std::fs::{self, File, OpenOptions};
+use std::io::{Read, Write};
+use std::path::{Path, PathBuf};
+use std::process::{Child, Command, ExitStatus, Stdio};
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::sync::{Arc, Mutex, OnceLock};
+use std::thread::{self, JoinHandle};
+use std::time::{Duration, Instant};
+
+use reqwest::blocking::{Client, RequestBuilder};
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+use sha2::{Digest, Sha256};
+
+use super::{
+    FixtureAllocation, HarnessError, Result, allocate_fixture, command_display,
+    current_target_profile_dir, now_ms, test_profile, workspace_root, yoi_binary_info,
+};
+
+const STARTUP_WAIT: Duration = Duration::from_secs(15);
+const EXIT_WAIT: Duration = Duration::from_secs(5);
+const HTTP_WAIT_STEP: Duration = Duration::from_millis(50);
+const MAX_PROCESS_LOG_BYTES: usize = 256 * 1024;
+const MAX_COMMAND_OUTPUT_BYTES: usize = 64 * 1024;
+static WORKER_ENV_COUNTER: AtomicU64 = AtomicU64::new(0);
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct WorkerBinaryRecord {
+    pub name: String,
+    pub path: PathBuf,
+    pub sha256: String,
+    pub provider: String,
+    pub build_command: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct WorkerBinaryProviderInfo {
+    pub workspace_root: PathBuf,
+    pub profile: String,
+    pub binaries: Vec<WorkerBinaryRecord>,
+}
+
+impl WorkerBinaryProviderInfo {
+    pub fn binary(&self, name: &str) -> Result<PathBuf> {
+        self.binaries
+            .iter()
+            .find(|record| record.name == name)
+            .map(|record| record.path.clone())
+            .ok_or_else(|| HarnessError::Protocol(format!("binary provider omitted {name}")))
+    }
+}
+
+pub fn worker_binary_provider_info() -> Result<WorkerBinaryProviderInfo> {
+    static INFO: OnceLock<std::result::Result<WorkerBinaryProviderInfo, String>> = OnceLock::new();
+    match INFO.get_or_init(|| resolve_worker_binaries().map_err(|error| error.to_string())) {
+        Ok(info) => Ok(info.clone()),
+        Err(message) => Err(HarnessError::Protocol(message.clone())),
+    }
+}
+
+fn resolve_worker_binaries() -> Result<WorkerBinaryProviderInfo> {
+    let workspace_root = workspace_root()?;
+    let profile = test_profile();
+    let yoi = yoi_binary_info()?;
+    let mut records = vec![binary_record(
+        "yoi",
+        yoi.binary,
+        yoi.provider,
+        yoi.build_command,
+    )?];
+
+    let server_override = resolve_override("YOI_E2E_SERVER_BIN", &workspace_root)?;
+    let runtime_override = resolve_override("YOI_E2E_RUNTIME_BIN", &workspace_root)?;
+    let mut build_command = None;
+    if server_override.is_none() || runtime_override.is_none() {
+        let cargo = PathBuf::from(std::env::var_os("CARGO").unwrap_or_else(|| "cargo".into()));
+        let mut args = vec![
+            "build".to_string(),
+            "-p".to_string(),
+            "yoi-workspace-server".to_string(),
+            "--bin".to_string(),
+            "yoi-server".to_string(),
+            "-p".to_string(),
+            "worker-runtime".to_string(),
+            "--bin".to_string(),
+            "yoi-runtime".to_string(),
+        ];
+        if profile == "release" {
+            args.push("--release".to_string());
+        }
+        let rendered = command_display(&cargo, &args);
+        eprintln!("yoi-e2e worker binary provider=cargo-build command={rendered}");
+        let output = Command::new(&cargo)
+            .args(&args)
+            .current_dir(&workspace_root)
+            .output()?;
+        if !output.status.success() {
+            return Err(HarnessError::CommandFailed {
+                program: cargo,
+                args,
+                status: output.status,
+                stdout: bounded_text(&output.stdout, MAX_COMMAND_OUTPUT_BYTES),
+                stderr: bounded_text(&output.stderr, MAX_COMMAND_OUTPUT_BYTES),
+            });
+        }
+        build_command = Some(rendered);
+    }
+
+    let profile_dir = current_target_profile_dir()?;
+    let (server_path, server_provider, server_build) = match server_override {
+        Some(path) => (path, "YOI_E2E_SERVER_BIN".to_string(), None),
+        None => (
+            profile_dir.join(executable_name("yoi-server")),
+            "cargo-build".to_string(),
+            build_command.clone(),
+        ),
+    };
+    let (runtime_path, runtime_provider, runtime_build) = match runtime_override {
+        Some(path) => (path, "YOI_E2E_RUNTIME_BIN".to_string(), None),
+        None => (
+            profile_dir.join(executable_name("yoi-runtime")),
+            "cargo-build".to_string(),
+            build_command,
+        ),
+    };
+    records.push(binary_record(
+        "yoi-server",
+        server_path,
+        server_provider,
+        server_build,
+    )?);
+    records.push(binary_record(
+        "yoi-runtime",
+        runtime_path,
+        runtime_provider,
+        runtime_build,
+    )?);
+
+    let info = WorkerBinaryProviderInfo {
+        workspace_root: workspace_root.clone(),
+        profile,
+        binaries: records,
+    };
+    let artifact_dir = workspace_root.join("target/e2e-artifacts");
+    fs::create_dir_all(&artifact_dir)?;
+    fs::write(
+        artifact_dir.join("worker-binary-provider.json"),
+        serde_json::to_vec_pretty(&info)?,
+    )?;
+    Ok(info)
+}
+
+fn resolve_override(name: &str, workspace_root: &Path) -> Result<Option<PathBuf>> {
+    let Some(path) = std::env::var_os(name) else {
+        return Ok(None);
+    };
+    let path = PathBuf::from(path);
+    let path = if path.is_absolute() {
+        path
+    } else {
+        workspace_root.join(path)
+    };
+    if !path.is_file() {
+        return Err(HarnessError::MissingBinary(path));
+    }
+    Ok(Some(path))
+}
+
+fn binary_record(
+    name: &str,
+    path: PathBuf,
+    provider: String,
+    build_command: Option<String>,
+) -> Result<WorkerBinaryRecord> {
+    if !path.is_file() {
+        return Err(HarnessError::MissingBinary(path));
+    }
+    let bytes = fs::read(&path)?;
+    let digest = Sha256::digest(bytes);
+    Ok(WorkerBinaryRecord {
+        name: name.to_string(),
+        path,
+        sha256: format!(
+            "sha256:{}",
+            digest
+                .iter()
+                .map(|byte| format!("{byte:02x}"))
+                .collect::<String>()
+        ),
+        provider,
+        build_command,
+    })
+}
+
+fn executable_name(name: &str) -> String {
+    format!("{name}{}", std::env::consts::EXE_SUFFIX)
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct WorkerEnvironmentCleanupReport {
+    pub fixture_root: PathBuf,
+    pub artifacts_dir: PathBuf,
+    pub cleanup_attempted: bool,
+    pub cleanup_success: bool,
+    pub fixture_root_exists_after: bool,
+    pub cleanup_error: Option<String>,
+    pub report_path: PathBuf,
+}
+
+#[derive(Debug)]
+pub struct WorkerE2eEnvironment {
+    temp_root: Option<tempfile::TempDir>,
+    pub root: PathBuf,
+    pub home: PathBuf,
+    pub xdg_data_home: PathBuf,
+    pub xdg_state_home: PathBuf,
+    pub xdg_config_home: PathBuf,
+    pub xdg_runtime_dir: PathBuf,
+    pub server_data_dir: PathBuf,
+    pub runtime_data_dir: PathBuf,
+    pub server_config: PathBuf,
+    pub artifacts_dir: PathBuf,
+    pub workspace_id: Option<String>,
+    pub runtime_id: String,
+    pub account_handle: String,
+    pub server_url: Option<String>,
+    pub runtime_url: Option<String>,
+    server: Option<ManagedProcess>,
+    runtime: Option<ManagedProcess>,
+    access_token: Option<String>,
+    client: Client,
+    binaries: WorkerBinaryProviderInfo,
+}
+
+impl WorkerE2eEnvironment {
+    pub fn new() -> Result<Self> {
+        let allocation = allocate_fixture("worker")?;
+        Self::from_allocation(allocation)
+    }
+
+    fn from_allocation(allocation: FixtureAllocation) -> Result<Self> {
+        let unique = format!(
+            "{}-{}-{}",
+            std::process::id(),
+            now_ms(),
+            WORKER_ENV_COUNTER.fetch_add(1, Ordering::Relaxed)
+        );
+        let server_data_dir = allocation.xdg_data_home.join("yoi/server");
+        let runtime_data_dir = allocation.root.join("runtime-data");
+        assert_absent_or_empty(&server_data_dir, "Server data directory")?;
+        assert_absent_or_empty(&runtime_data_dir, "Runtime data directory")?;
+        let server_config = allocation.xdg_config_home.join("yoi/server.toml");
+        if let Some(parent) = server_config.parent() {
+            fs::create_dir_all(parent)?;
+        }
+        fs::write(
+            &server_config,
+            "[browser]\npublic_url = \"http://localhost:5173\"\n",
+        )?;
+        let binaries = worker_binary_provider_info()?;
+        fs::write(
+            allocation.artifacts_dir.join("binary-provider.json"),
+            serde_json::to_vec_pretty(&binaries)?,
+        )?;
+        let client = Client::builder()
+            .connect_timeout(Duration::from_secs(1))
+            .timeout(Duration::from_secs(3))
+            .build()
+            .map_err(|error| HarnessError::Protocol(format!("build E2E HTTP client: {error}")))?;
+        let environment = Self {
+            temp_root: Some(allocation.temp_root),
+            root: allocation.root,
+            home: allocation.home,
+            xdg_data_home: allocation.xdg_data_home,
+            xdg_state_home: allocation.xdg_state_home,
+            xdg_config_home: allocation.xdg_config_home,
+            xdg_runtime_dir: allocation.xdg_runtime_dir,
+            server_data_dir,
+            runtime_data_dir,
+            server_config,
+            artifacts_dir: allocation.artifacts_dir,
+            workspace_id: None,
+            runtime_id: format!("runtime-{unique}"),
+            account_handle: format!("e2e-{}-{}", std::process::id(), unique.replace('-', "")),
+            server_url: None,
+            runtime_url: None,
+            server: None,
+            runtime: None,
+            access_token: None,
+            client,
+            binaries,
+        };
+        environment.write_metadata("created")?;
+        Ok(environment)
+    }
+
+    pub fn start(&mut self) -> Result<()> {
+        assert_absent_or_empty(&self.server_data_dir, "Server data directory")?;
+        assert_absent_or_empty(&self.runtime_data_dir, "Runtime data directory")?;
+        let server_binary = self.binaries.binary("yoi-server")?;
+        let mut command = self.isolated_command(&server_binary);
+        command.args([
+            "serve",
+            "--listen",
+            "127.0.0.1:0",
+            "--config",
+            self.server_config.to_string_lossy().as_ref(),
+        ]);
+        let server = ManagedProcess::spawn(
+            "server",
+            command,
+            &self.artifacts_dir.join("server.stdout.log"),
+            &self.artifacts_dir.join("server.stderr.log"),
+        )?;
+        let server_addr = server.wait_for_address("on http://", STARTUP_WAIT)?;
+        let server_url = format!("http://{server_addr}");
+        self.server = Some(server);
+        self.server_url = Some(server_url.clone());
+        self.wait_for_server_health(&server_url)?;
+
+        let bootstrap = self.run_command(
+            &server_binary,
+            &[
+                "bootstrap-auth",
+                "--handle",
+                &self.account_handle,
+                "--display-name",
+                "Yoi Worker E2E",
+                "--label",
+                "worker-e2e-bootstrap",
+            ],
+            true,
+        )?;
+        let bootstrap: Value = serde_json::from_slice(&bootstrap.stdout)?;
+        self.access_token = bootstrap
+            .get("access_token")
+            .and_then(Value::as_str)
+            .map(str::to_owned);
+        if self.access_token.is_none() {
+            return Err(HarnessError::Protocol(
+                "bootstrap-auth omitted access_token".to_string(),
+            ));
+        }
+
+        let created = self.request_json(
+            self.client
+                .post(format!("{server_url}/api/workspaces"))
+                .json(&serde_json::json!({
+                    "operation_key": format!("worker-e2e-{}", self.runtime_id),
+                    "display_name": format!("Worker E2E {}", self.runtime_id),
+                    "repository": {
+                        "repository_key": "fixture",
+                        "uri": "https://example.invalid/yoi-e2e.git",
+                        "default_ref": "develop"
+                    }
+                })),
+            "create Workspace",
+        )?;
+        let workspace_id = json_string(&created, "/workspace/workspace_id")?;
+        self.workspace_id = Some(workspace_id.clone());
+        let identity = self.request_json(
+            self.client.get(format!(
+                "{server_url}/api/w/{workspace_id}/settings/signing-identity"
+            )),
+            "read Workspace signing identity",
+        )?;
+        let public_bundle = identity.get("public_bundle").cloned().ok_or_else(|| {
+            HarnessError::Protocol("Workspace public bundle is absent".to_string())
+        })?;
+        let bundle_path = self.root.join("workspace-public-identity.json");
+        fs::write(&bundle_path, serde_json::to_vec_pretty(&public_bundle)?)?;
+
+        let runtime_binary = self.binaries.binary("yoi-runtime")?;
+        self.run_command(
+            &runtime_binary,
+            &[
+                "identity",
+                "init",
+                "--runtime-id",
+                &self.runtime_id,
+                "--fs-root",
+                self.runtime_data_dir.to_string_lossy().as_ref(),
+            ],
+            false,
+        )?;
+        let runtime_identity = self.run_command(
+            &runtime_binary,
+            &[
+                "identity",
+                "show",
+                "--json",
+                "--fs-root",
+                self.runtime_data_dir.to_string_lossy().as_ref(),
+            ],
+            false,
+        )?;
+        let runtime_identity: Value = serde_json::from_slice(&runtime_identity.stdout)?;
+        self.run_command(
+            &runtime_binary,
+            &[
+                "trust-workspace",
+                "add",
+                "--bundle",
+                bundle_path.to_string_lossy().as_ref(),
+                "--fs-root",
+                self.runtime_data_dir.to_string_lossy().as_ref(),
+            ],
+            false,
+        )?;
+
+        let mut command = self.isolated_command(&runtime_binary);
+        command.args([
+            "--bind",
+            "127.0.0.1:0",
+            "--display-name",
+            &format!("E2E {}", self.runtime_id),
+            "--store",
+            "fs",
+            "--fs-root",
+            self.runtime_data_dir.to_string_lossy().as_ref(),
+        ]);
+        let runtime = ManagedProcess::spawn(
+            "runtime",
+            command,
+            &self.artifacts_dir.join("runtime.stdout.log"),
+            &self.artifacts_dir.join("runtime.stderr.log"),
+        )?;
+        let runtime_addr = runtime.wait_for_address("listening on ", STARTUP_WAIT)?;
+        let runtime_url = format!("http://{runtime_addr}");
+        self.runtime = Some(runtime);
+        self.runtime_url = Some(runtime_url.clone());
+
+        self.request_json(
+            self.client
+                .post(format!("{server_url}/api/w/{workspace_id}/runtimes"))
+                .json(&serde_json::json!({
+                    "public_bundle": runtime_identity,
+                    "display_name": format!("E2E {}", self.runtime_id),
+                    "endpoint": runtime_url,
+                    "expected_revision": null
+                })),
+            "register Runtime",
+        )?;
+        let connection = self.request_json(
+            self.client.post(format!(
+                "{server_url}/api/w/{workspace_id}/runtimes/{}/connection-tests",
+                self.runtime_id
+            )),
+            "verify Runtime connection",
+        )?;
+        if connection.get("status").and_then(Value::as_str) != Some("compatible") {
+            return Err(HarnessError::Protocol(format!(
+                "Runtime connection was not compatible: {connection}"
+            )));
+        }
+        self.assert_connected_and_empty()?;
+        self.write_metadata("running")?;
+        Ok(())
+    }
+
+    pub fn assert_connected_and_empty(&self) -> Result<()> {
+        let server_url = self.required_server_url()?;
+        let workspace_id = self.required_workspace_id()?;
+        let runtimes = self.request_json(
+            self.client
+                .get(format!("{server_url}/api/w/{workspace_id}/runtimes")),
+            "list Runtimes",
+        )?;
+        let connected = runtimes
+            .get("items")
+            .and_then(Value::as_array)
+            .is_some_and(|items| {
+                items.iter().any(|item| {
+                    item.get("runtime_id").and_then(Value::as_str) == Some(self.runtime_id.as_str())
+                        && item
+                            .pointer("/management/binding/connection_state")
+                            .and_then(Value::as_str)
+                            == Some("verified")
+                })
+            });
+        if !connected {
+            return Err(HarnessError::Protocol(format!(
+                "Runtime {} is not verified in {runtimes}",
+                self.runtime_id
+            )));
+        }
+        let workers = self.request_json(
+            self.client
+                .get(format!("{server_url}/api/w/{workspace_id}/workers")),
+            "list Workers",
+        )?;
+        if workers
+            .get("items")
+            .and_then(Value::as_array)
+            .is_none_or(|items| !items.is_empty())
+        {
+            return Err(HarnessError::Protocol(format!(
+                "fresh Worker list is not empty: {workers}"
+            )));
+        }
+        Ok(())
+    }
+
+    pub fn server_port(&self) -> Result<u16> {
+        url_port(self.required_server_url()?)
+    }
+
+    pub fn runtime_port(&self) -> Result<u16> {
+        url_port(
+            self.runtime_url
+                .as_deref()
+                .ok_or_else(|| HarnessError::Protocol("Runtime is not started".to_string()))?,
+        )
+    }
+
+    pub fn server_pid(&self) -> Option<u32> {
+        self.server.as_ref().map(ManagedProcess::id)
+    }
+
+    pub fn runtime_pid(&self) -> Option<u32> {
+        self.runtime.as_ref().map(ManagedProcess::id)
+    }
+
+    pub fn shutdown(&mut self) -> Result<()> {
+        if let Some(mut runtime) = self.runtime.take() {
+            runtime.shutdown(EXIT_WAIT)?;
+        }
+        if let Some(mut server) = self.server.take() {
+            server.shutdown(EXIT_WAIT)?;
+        }
+        self.write_metadata("stopped")?;
+        Ok(())
+    }
+
+    pub fn cleanup(mut self) -> Result<WorkerEnvironmentCleanupReport> {
+        self.shutdown()?;
+        self.cleanup_inner(true)
+    }
+
+    fn cleanup_inner(&mut self, strict: bool) -> Result<WorkerEnvironmentCleanupReport> {
+        let mut cleanup_error = None;
+        if let Some(temp_root) = self.temp_root.take()
+            && let Err(error) = temp_root.close()
+        {
+            cleanup_error = Some(error.to_string());
+        }
+        let fixture_root_exists_after = self.root.exists();
+        let cleanup_success = cleanup_error.is_none() && !fixture_root_exists_after;
+        let report = WorkerEnvironmentCleanupReport {
+            fixture_root: self.root.clone(),
+            artifacts_dir: self.artifacts_dir.clone(),
+            cleanup_attempted: true,
+            cleanup_success,
+            fixture_root_exists_after,
+            cleanup_error,
+            report_path: self.artifacts_dir.join("cleanup.json"),
+        };
+        fs::write(&report.report_path, serde_json::to_vec_pretty(&report)?)?;
+        if strict && !report.cleanup_success {
+            return Err(HarnessError::Protocol(format!(
+                "Worker E2E cleanup failed; see {}",
+                report.report_path.display()
+            )));
+        }
+        Ok(report)
+    }
+
+    fn wait_for_server_health(&self, server_url: &str) -> Result<()> {
+        let deadline = Instant::now() + STARTUP_WAIT;
+        loop {
+            let last = match self.client.get(format!("{server_url}/health")).send() {
+                Ok(response) if response.status().is_success() => return Ok(()),
+                Ok(response) => format!("HTTP {}", response.status()),
+                Err(error) => error.to_string(),
+            };
+            if Instant::now() >= deadline {
+                return Err(HarnessError::Protocol(format!(
+                    "Server health did not become ready: {last}"
+                )));
+            }
+            if let Some(server) = self.server.as_ref()
+                && !server.is_running()
+            {
+                return Err(HarnessError::Protocol(
+                    "Server exited before health became ready".to_string(),
+                ));
+            }
+            thread::sleep(HTTP_WAIT_STEP);
+        }
+    }
+
+    fn request_json(&self, request: RequestBuilder, operation: &str) -> Result<Value> {
+        let request = if let Some(token) = self.access_token.as_deref() {
+            request.bearer_auth(token)
+        } else {
+            request
+        };
+        let response = request
+            .send()
+            .map_err(|error| HarnessError::Protocol(format!("{operation}: {error}")))?;
+        let status = response.status();
+        let body = response
+            .bytes()
+            .map_err(|error| HarnessError::Protocol(format!("{operation}: {error}")))?;
+        self.append_operation(operation, status.as_u16())?;
+        if !status.is_success() {
+            return Err(HarnessError::Protocol(format!(
+                "{operation} returned {status}: {}",
+                bounded_text(&body, MAX_COMMAND_OUTPUT_BYTES)
+            )));
+        }
+        serde_json::from_slice(&body).map_err(HarnessError::from)
+    }
+
+    fn append_operation(&self, operation: &str, status: u16) -> Result<()> {
+        let mut file = OpenOptions::new()
+            .create(true)
+            .append(true)
+            .open(self.artifacts_dir.join("operations.jsonl"))?;
+        serde_json::to_writer(
+            &mut file,
+            &serde_json::json!({
+                "ts_ms": now_ms(),
+                "operation": operation,
+                "status": status,
+            }),
+        )?;
+        writeln!(file)?;
+        Ok(())
+    }
+
+    fn run_command(
+        &self,
+        binary: &Path,
+        args: &[&str],
+        redact_stdout: bool,
+    ) -> Result<std::process::Output> {
+        let args_owned = args
+            .iter()
+            .map(|arg| (*arg).to_string())
+            .collect::<Vec<_>>();
+        let mut command = self.isolated_command(binary);
+        let output = command.args(args).output()?;
+        let mut log = OpenOptions::new()
+            .create(true)
+            .append(true)
+            .open(self.artifacts_dir.join("setup-commands.jsonl"))?;
+        serde_json::to_writer(
+            &mut log,
+            &serde_json::json!({
+                "ts_ms": now_ms(),
+                "binary": binary,
+                "args": args,
+                "status": output.status.code(),
+                "stdout": if redact_stdout { "<redacted>" } else { "captured-not-persisted" },
+                "env_clear": true,
+            }),
+        )?;
+        writeln!(log)?;
+        if !output.status.success() {
+            return Err(HarnessError::CommandFailed {
+                program: binary.to_path_buf(),
+                args: args_owned,
+                status: output.status,
+                stdout: if redact_stdout {
+                    "<redacted>".to_string()
+                } else {
+                    bounded_text(&output.stdout, MAX_COMMAND_OUTPUT_BYTES)
+                },
+                stderr: bounded_text(&output.stderr, MAX_COMMAND_OUTPUT_BYTES),
+            });
+        }
+        Ok(output)
+    }
+
+    fn isolated_command(&self, binary: &Path) -> Command {
+        let mut command = Command::new(binary);
+        command
+            .current_dir(&self.root)
+            .env_clear()
+            .env("HOME", &self.home)
+            .env("XDG_DATA_HOME", &self.xdg_data_home)
+            .env("XDG_STATE_HOME", &self.xdg_state_home)
+            .env("XDG_CONFIG_HOME", &self.xdg_config_home)
+            .env("XDG_RUNTIME_DIR", &self.xdg_runtime_dir);
+        command
+    }
+
+    fn required_server_url(&self) -> Result<&str> {
+        self.server_url
+            .as_deref()
+            .ok_or_else(|| HarnessError::Protocol("Server is not started".to_string()))
+    }
+
+    fn required_workspace_id(&self) -> Result<&str> {
+        self.workspace_id
+            .as_deref()
+            .ok_or_else(|| HarnessError::Protocol("Workspace is not created".to_string()))
+    }
+
+    fn write_metadata(&self, phase: &str) -> Result<()> {
+        fs::write(
+            self.artifacts_dir.join("worker-environment.json"),
+            serde_json::to_vec_pretty(&serde_json::json!({
+                "phase": phase,
+                "fixture_root": self.root,
+                "server_data_dir": self.server_data_dir,
+                "runtime_data_dir": self.runtime_data_dir,
+                "home": self.home,
+                "xdg_data_home": self.xdg_data_home,
+                "xdg_state_home": self.xdg_state_home,
+                "xdg_config_home": self.xdg_config_home,
+                "xdg_runtime_dir": self.xdg_runtime_dir,
+                "server_config": self.server_config,
+                "artifacts_dir": self.artifacts_dir,
+                "workspace_id": self.workspace_id,
+                "runtime_id": self.runtime_id,
+                "account_handle": self.account_handle,
+                "server_url": self.server_url,
+                "runtime_url": self.runtime_url,
+                "server_pid": self.server_pid(),
+                "runtime_pid": self.runtime_pid(),
+                "env_clear": true,
+                "credentials_persisted_to_artifacts": false,
+            }))?,
+        )?;
+        Ok(())
+    }
+}
+
+impl Drop for WorkerE2eEnvironment {
+    fn drop(&mut self) {
+        if let Some(mut runtime) = self.runtime.take() {
+            let _ = runtime.shutdown(EXIT_WAIT);
+        }
+        if let Some(mut server) = self.server.take() {
+            let _ = server.shutdown(EXIT_WAIT);
+        }
+        if self.temp_root.is_some() {
+            let _ = self.cleanup_inner(false);
+        }
+    }
+}
+
+#[derive(Debug)]
+struct ManagedProcess {
+    name: String,
+    child: Child,
+    stdout: Arc<Mutex<Vec<u8>>>,
+    stderr: Arc<Mutex<Vec<u8>>>,
+    readers: Vec<JoinHandle<()>>,
+}
+
+impl ManagedProcess {
+    fn spawn(
+        name: &str,
+        mut command: Command,
+        stdout_path: &Path,
+        stderr_path: &Path,
+    ) -> Result<Self> {
+        command.stdout(Stdio::piped()).stderr(Stdio::piped());
+        let mut child = command.spawn()?;
+        let stdout_pipe = child
+            .stdout
+            .take()
+            .ok_or_else(|| HarnessError::Protocol(format!("{name} stdout was not piped")))?;
+        let stderr_pipe = child
+            .stderr
+            .take()
+            .ok_or_else(|| HarnessError::Protocol(format!("{name} stderr was not piped")))?;
+        let stdout = Arc::new(Mutex::new(Vec::new()));
+        let stderr = Arc::new(Mutex::new(Vec::new()));
+        let readers = vec![
+            capture_stream(stdout_pipe, stdout_path.to_path_buf(), Arc::clone(&stdout)),
+            capture_stream(stderr_pipe, stderr_path.to_path_buf(), Arc::clone(&stderr)),
+        ];
+        Ok(Self {
+            name: name.to_string(),
+            child,
+            stdout,
+            stderr,
+            readers,
+        })
+    }
+
+    fn id(&self) -> u32 {
+        self.child.id()
+    }
+
+    fn is_running(&self) -> bool {
+        unsafe { libc::kill(self.child.id() as i32, 0) == 0 }
+    }
+
+    fn wait_for_address(&self, marker: &str, timeout: Duration) -> Result<String> {
+        let start = Instant::now();
+        loop {
+            let output = self.output();
+            if let Some(address) = parse_address_after(&output, marker) {
+                return Ok(address);
+            }
+            if start.elapsed() >= timeout {
+                return Err(HarnessError::Protocol(format!(
+                    "timed out waiting for {} address after {marker:?}; bounded output: {}",
+                    self.name,
+                    bounded_text(output.as_bytes(), 8 * 1024)
+                )));
+            }
+            let rc = unsafe { libc::kill(self.child.id() as i32, 0) };
+            if rc != 0 {
+                return Err(HarnessError::Protocol(format!(
+                    "{} exited before publishing its address; bounded output: {}",
+                    self.name,
+                    bounded_text(output.as_bytes(), 8 * 1024)
+                )));
+            }
+            thread::sleep(Duration::from_millis(20));
+        }
+    }
+
+    fn output(&self) -> String {
+        let stdout = self
+            .stdout
+            .lock()
+            .map(|value| value.clone())
+            .unwrap_or_default();
+        let stderr = self
+            .stderr
+            .lock()
+            .map(|value| value.clone())
+            .unwrap_or_default();
+        format!(
+            "{}\n{}",
+            String::from_utf8_lossy(&stdout),
+            String::from_utf8_lossy(&stderr)
+        )
+    }
+
+    fn shutdown(&mut self, timeout: Duration) -> Result<ExitStatus> {
+        if let Some(status) = self.child.try_wait()? {
+            self.join_readers();
+            return Ok(status);
+        }
+        let signal_result = unsafe { libc::kill(self.child.id() as i32, libc::SIGTERM) };
+        if signal_result != 0 {
+            return Err(io_error("send SIGTERM", std::io::Error::last_os_error()));
+        }
+        let start = Instant::now();
+        loop {
+            if let Some(status) = self.child.try_wait()? {
+                self.join_readers();
+                if status.success() {
+                    return Ok(status);
+                }
+                return Err(HarnessError::Protocol(format!(
+                    "{} did not complete graceful shutdown: {status}",
+                    self.name
+                )));
+            }
+            if start.elapsed() >= timeout {
+                let _ = self.child.kill();
+                let _ = self.child.wait();
+                self.join_readers();
+                return Err(HarnessError::Protocol(format!(
+                    "{} did not exit within {timeout:?}",
+                    self.name
+                )));
+            }
+            thread::sleep(Duration::from_millis(20));
+        }
+    }
+
+    fn join_readers(&mut self) {
+        for reader in self.readers.drain(..) {
+            let _ = reader.join();
+        }
+    }
+}
+
+impl Drop for ManagedProcess {
+    fn drop(&mut self) {
+        if self.child.try_wait().ok().flatten().is_none() {
+            let _ = self.child.kill();
+            let _ = self.child.wait();
+        }
+        self.join_readers();
+    }
+}
+
+fn capture_stream(
+    mut stream: impl Read + Send + 'static,
+    path: PathBuf,
+    shared: Arc<Mutex<Vec<u8>>>,
+) -> JoinHandle<()> {
+    thread::spawn(move || {
+        let mut file = File::create(path).ok();
+        let mut written = 0usize;
+        let mut truncated = false;
+        let mut buffer = [0u8; 4096];
+        loop {
+            let count = match stream.read(&mut buffer) {
+                Ok(0) => break,
+                Ok(count) => count,
+                Err(error) if error.kind() == std::io::ErrorKind::Interrupted => continue,
+                Err(_) => break,
+            };
+            if let Ok(mut captured) = shared.lock()
+                && captured.len() < MAX_PROCESS_LOG_BYTES
+            {
+                let remaining = MAX_PROCESS_LOG_BYTES - captured.len();
+                captured.extend_from_slice(&buffer[..count.min(remaining)]);
+            }
+            if let Some(file) = file.as_mut() {
+                let remaining = MAX_PROCESS_LOG_BYTES.saturating_sub(written);
+                let keep = count.min(remaining);
+                if keep > 0 {
+                    let _ = file.write_all(&buffer[..keep]);
+                    written += keep;
+                }
+                if keep < count && !truncated {
+                    let _ = file.write_all(b"\n<bounded log truncated>\n");
+                    truncated = true;
+                }
+            }
+        }
+    })
+}
+
+fn parse_address_after(output: &str, marker: &str) -> Option<String> {
+    let rest = output.split(marker).nth(1)?;
+    let address = rest
+        .trim_start()
+        .split(|character: char| character.is_whitespace() || character == ';' || character == '`')
+        .next()?
+        .trim_start_matches("http://")
+        .trim_end_matches('/');
+    (!address.is_empty()).then(|| address.to_string())
+}
+
+fn assert_absent_or_empty(path: &Path, label: &str) -> Result<()> {
+    if !path.exists() {
+        return Ok(());
+    }
+    if path.is_dir() && fs::read_dir(path)?.next().is_none() {
+        return Ok(());
+    }
+    Err(HarnessError::Protocol(format!(
+        "{label} {} must start empty",
+        path.display()
+    )))
+}
+
+fn json_string(value: &Value, pointer: &str) -> Result<String> {
+    value
+        .pointer(pointer)
+        .and_then(Value::as_str)
+        .map(str::to_owned)
+        .ok_or_else(|| HarnessError::Protocol(format!("JSON response omitted {pointer}: {value}")))
+}
+
+fn url_port(url: &str) -> Result<u16> {
+    reqwest::Url::parse(url)
+        .ok()
+        .and_then(|url| url.port())
+        .ok_or_else(|| HarnessError::Protocol(format!("URL has no explicit port: {url}")))
+}
+
+fn bounded_text(bytes: &[u8], limit: usize) -> String {
+    let keep = bytes.len().min(limit);
+    let mut text = String::from_utf8_lossy(&bytes[..keep]).into_owned();
+    if bytes.len() > keep {
+        text.push_str("\n<bounded output truncated>");
+    }
+    text
+}
+
+fn io_error(operation: &str, error: std::io::Error) -> HarnessError {
+    HarnessError::Protocol(format!("{operation}: {error}"))
+}
diff --git a/tests/e2e/tests/rewind.rs b/tests/e2e/tests/rewind.rs
index e52b1d777..1493c2a0d 100644
--- a/tests/e2e/tests/rewind.rs
+++ b/tests/e2e/tests/rewind.rs
@@ -6,7 +6,7 @@ use yoi_e2e::{FixtureWorkspace, KeyPress, PanelHarness, yoi_binary};
 fn single_pod_rewind_picker_applies_without_escape_and_suppresses_duplicate_enter()
 -> yoi_e2e::Result<()> {
     let binary = yoi_binary()?;
-    let fixture = FixtureWorkspace::new(&binary)?;
+    let fixture = FixtureWorkspace::new_rewind(&binary)?;
     let mut tui = PanelHarness::spawn(fixture.rewind_fixture_config(binary))?;
 
     tui.expect_mouse_capture_enabled()?;
diff --git a/tests/e2e/tests/worker_environment.rs b/tests/e2e/tests/worker_environment.rs
new file mode 100644
index 000000000..2e876bf22
--- /dev/null
+++ b/tests/e2e/tests/worker_environment.rs
@@ -0,0 +1,72 @@
+use std::fs;
+
+use yoi_e2e::{Result, WorkerE2eEnvironment, WorkerEnvironmentCleanupReport};
+
+#[test]
+fn starts_server_and_runtime_from_empty_storage() -> Result<()> {
+    let mut environment = WorkerE2eEnvironment::new()?;
+    assert!(!environment.server_data_dir.exists());
+    assert!(!environment.runtime_data_dir.exists());
+
+    environment.start()?;
+
+    assert!(environment.server_data_dir.join("server.db").is_file());
+    assert!(
+        environment
+            .runtime_data_dir
+            .join("runtime/runtime.json")
+            .is_file()
+    );
+    environment.assert_connected_and_empty()?;
+    let artifacts_dir = environment.artifacts_dir.clone();
+    let report = environment.cleanup()?;
+    assert!(report.cleanup_success);
+    let persisted: WorkerEnvironmentCleanupReport =
+        serde_json::from_slice(&fs::read(artifacts_dir.join("cleanup.json"))?)?;
+    assert!(persisted.cleanup_success);
+    assert!(!persisted.fixture_root_exists_after);
+    Ok(())
+}
+
+#[test]
+fn concurrent_environments_are_isolated_and_cleanup_is_local() -> Result<()> {
+    let mut first = WorkerE2eEnvironment::new()?;
+    let mut second = WorkerE2eEnvironment::new()?;
+    assert_ne!(first.root, second.root);
+    assert_ne!(first.server_data_dir, second.server_data_dir);
+    assert_ne!(first.runtime_data_dir, second.runtime_data_dir);
+    assert_ne!(first.runtime_id, second.runtime_id);
+    assert_ne!(first.account_handle, second.account_handle);
+    assert_ne!(first.artifacts_dir, second.artifacts_dir);
+
+    first.start()?;
+    second.start()?;
+
+    assert_ne!(first.server_port()?, second.server_port()?);
+    assert_ne!(first.runtime_port()?, second.runtime_port()?);
+    assert_ne!(first.server_pid(), second.server_pid());
+    assert_ne!(first.runtime_pid(), second.runtime_pid());
+    assert_ne!(first.workspace_id, second.workspace_id);
+    first.assert_connected_and_empty()?;
+    second.assert_connected_and_empty()?;
+
+    let second_root = second.root.clone();
+    let second_server_data = second.server_data_dir.clone();
+    let second_runtime_data = second.runtime_data_dir.clone();
+    let second_artifacts = second.artifacts_dir.clone();
+    let first_artifacts = first.artifacts_dir.clone();
+    let first_report = first.cleanup()?;
+    assert!(first_report.cleanup_success);
+    assert!(first_artifacts.is_dir());
+
+    assert!(second_root.is_dir());
+    assert!(second_server_data.is_dir());
+    assert!(second_runtime_data.is_dir());
+    assert!(second_artifacts.is_dir());
+    second.assert_connected_and_empty()?;
+
+    let second_report = second.cleanup()?;
+    assert!(second_report.cleanup_success);
+    assert!(second_artifacts.join("cleanup.json").is_file());
+    Ok(())
+}

From a6890727560af09a1b6a2e46c021fa4d6d26f8bd Mon Sep 17 00:00:00 2001
From: Hare <kei.hiracchi.0928@gmail.com>
Date: Tue, 22 Sep 2026 23:28:28 +0900
Subject: [PATCH 2/2] fix(e2e): close worker environment review gaps

---
 crates/client/src/workspace_product.rs |  44 +-
 crates/tui/src/backend_dashboard.rs    | 100 +++-
 crates/tui/src/e2e_observer.rs         |  22 +-
 crates/worker-runtime/src/fs_store.rs  |  87 ++-
 tests/e2e/src/lib.rs                   | 370 ++-----------
 tests/e2e/src/worker_environment.rs    | 106 +++-
 tests/e2e/tests/panel.rs               | 739 +++++--------------------
 7 files changed, 509 insertions(+), 959 deletions(-)

diff --git a/crates/client/src/workspace_product.rs b/crates/client/src/workspace_product.rs
index f69c61927..f87e62dab 100644
--- a/crates/client/src/workspace_product.rs
+++ b/crates/client/src/workspace_product.rs
@@ -1,6 +1,6 @@
 use reqwest::Method;
-use serde::Serialize;
 use serde::de::DeserializeOwned;
+use serde::{Deserialize, Serialize};
 use server_api::{
     BrowserCreateWorkerResponse, BrowserWorkspaceOrchestratorResponse,
     CreateWorkspaceWorkerRequest, ListResponse, MemoryDocumentResponse, MemoryStagingListResponse,
@@ -22,6 +22,21 @@ use crate::{BackendApiClient, BackendWorkspaceClientError};
 
 const DEFAULT_PRODUCT_LIST_LIMIT: usize = 1_000;
 
+#[derive(Debug, Deserialize)]
+struct BackendObjectiveListResponse {
+    workspace_id: String,
+    limit: usize,
+    items: Vec<ObjectiveSummary>,
+    invalid_records: Vec<BackendInvalidProjectRecord>,
+    record_authority: String,
+}
+
+#[derive(Debug, Deserialize)]
+struct BackendInvalidProjectRecord {
+    label: String,
+    reason: String,
+}
+
 /// Workspace-scoped Backend client for Ticket and Objective product state.
 ///
 /// Construction requires both the selected Backend URL and Workspace identity.
@@ -177,7 +192,23 @@ impl BackendWorkspaceProductClient {
         &self,
         limit: usize,
     ) -> Result<ListResponse<ObjectiveSummary>, BackendWorkspaceClientError> {
-        self.get_json(&format!("/objectives?limit={limit}"))
+        let response: BackendObjectiveListResponse =
+            self.get_json(&format!("/objectives?limit={limit}"))?;
+        Ok(ListResponse {
+            workspace_id: response.workspace_id,
+            limit: response.limit,
+            items: response.items,
+            source: response.record_authority,
+            diagnostics: response
+                .invalid_records
+                .into_iter()
+                .map(|invalid| server_api::Diagnostic {
+                    code: "invalid_objective_record".to_string(),
+                    severity: server_api::DiagnosticSeverity::Warning,
+                    message: format!("{}: {}", invalid.label, invalid.reason),
+                })
+                .collect(),
+        })
     }
 
     pub fn show_objective(&self, id: &str) -> Result<ObjectiveDetail, BackendWorkspaceClientError> {
@@ -794,7 +825,7 @@ mod tests {
 
     #[test]
     fn objective_list_uses_workspace_scoped_backend_route() {
-        let body = r#"{"workspace_id":"workspace-a","limit":1000,"items":[],"source":"sqlite","diagnostics":[]}"#;
+        let body = r#"{"workspace_id":"workspace-a","limit":1000,"items":[],"invalid_records":[{"label":"broken.md","reason":"invalid frontmatter"}],"record_authority":"sqlite"}"#;
         let (base_url, request, handle) = one_response_server("200 OK", body);
         let client = BackendWorkspaceProductClient::new_with_access_token(
             base_url,
@@ -806,6 +837,13 @@ mod tests {
         let response = client.list_objectives(1_000).unwrap();
 
         assert!(response.items.is_empty());
+        assert_eq!(response.source, "sqlite");
+        assert_eq!(response.diagnostics.len(), 1);
+        assert_eq!(response.diagnostics[0].code, "invalid_objective_record");
+        assert_eq!(
+            response.diagnostics[0].message,
+            "broken.md: invalid frontmatter"
+        );
         let request = request.recv().unwrap();
         assert!(request.starts_with("GET /api/w/workspace-a/objectives?limit=1000 "));
         assert!(request.contains("authorization: Bearer test-backend-token\r\n"));
diff --git a/crates/tui/src/backend_dashboard.rs b/crates/tui/src/backend_dashboard.rs
index 7fcdc36cb..fc8a88ae5 100644
--- a/crates/tui/src/backend_dashboard.rs
+++ b/crates/tui/src/backend_dashboard.rs
@@ -2,7 +2,7 @@ use std::io;
 use std::time::Duration;
 
 use client::{BackendWorkspaceProductClient, ObjectiveSummary};
-use crossterm::event::{self, Event, KeyCode, KeyEventKind};
+use crossterm::event::{self, Event, KeyCode, KeyEventKind, KeyModifiers};
 use ratatui::{
     Frame, Terminal,
     backend::CrosstermBackend,
@@ -79,8 +79,26 @@ async fn run_loop(
     app: &mut BackendDashboard,
     client: BackendWorkspaceProductClient,
 ) -> Result<(), Box<dyn std::error::Error>> {
+    let mut first_frame = true;
+    let mut initial_snapshot_pending = false;
     loop {
         terminal.draw(|frame| draw(frame, app))?;
+        if first_frame {
+            first_frame = false;
+            #[cfg(feature = "e2e-test")]
+            {
+                crate::e2e_observer::emit(
+                    "backend_dashboard",
+                    "panel_ready",
+                    serde_json::json!({ "workspace_id": app.workspace_id }),
+                );
+                initial_snapshot_pending = true;
+            }
+        } else if initial_snapshot_pending {
+            #[cfg(feature = "e2e-test")]
+            emit_e2e_snapshot(app, "backend_dashboard_content_ready");
+            initial_snapshot_pending = false;
+        }
         if !event::poll(Duration::from_millis(100))? {
             continue;
         }
@@ -91,21 +109,50 @@ async fn run_loop(
             continue;
         }
         match key.code {
-            KeyCode::Char('q') | KeyCode::Esc => return Ok(()),
+            KeyCode::Char('q') | KeyCode::Esc => {
+                #[cfg(feature = "e2e-test")]
+                crate::e2e_observer::emit(
+                    "backend_dashboard",
+                    "quit_requested",
+                    serde_json::json!({}),
+                );
+                return Ok(());
+            }
+            KeyCode::Char('c') if key.modifiers.contains(KeyModifiers::CONTROL) => {
+                #[cfg(feature = "e2e-test")]
+                crate::e2e_observer::emit(
+                    "backend_dashboard",
+                    "quit_requested",
+                    serde_json::json!({}),
+                );
+                return Ok(());
+            }
             KeyCode::Tab | KeyCode::BackTab => {
                 app.focus = match app.focus {
                     Focus::Tickets => Focus::Objectives,
                     Focus::Objectives => Focus::Tickets,
                 };
+                #[cfg(feature = "e2e-test")]
+                emit_e2e_snapshot(app, "backend_dashboard_selection_changed");
+            }
+            KeyCode::Down | KeyCode::Char('j') => {
+                app.select_next();
+                #[cfg(feature = "e2e-test")]
+                emit_e2e_snapshot(app, "backend_dashboard_selection_changed");
+            }
+            KeyCode::Up | KeyCode::Char('k') => {
+                app.select_previous();
+                #[cfg(feature = "e2e-test")]
+                emit_e2e_snapshot(app, "backend_dashboard_selection_changed");
             }
-            KeyCode::Down | KeyCode::Char('j') => app.select_next(),
-            KeyCode::Up | KeyCode::Char('k') => app.select_previous(),
             KeyCode::Char('r') => match load(&client).await {
                 Ok((tickets, objectives)) => {
                     app.tickets = tickets;
                     app.objectives = objectives;
                     app.clamp_selection();
                     app.status = "Reloaded from Backend authority".to_string();
+                    #[cfg(feature = "e2e-test")]
+                    emit_e2e_snapshot(app, "backend_dashboard_reloaded");
                 }
                 Err(error) => app.status = format!("Backend reload failed: {error}"),
             },
@@ -144,6 +191,51 @@ async fn run_loop(
     }
 }
 
+#[cfg(feature = "e2e-test")]
+fn emit_e2e_snapshot(app: &BackendDashboard, event: &'static str) {
+    let focus = match app.focus {
+        Focus::Tickets => "tickets",
+        Focus::Objectives => "objectives",
+    };
+    let tickets = app
+        .tickets
+        .iter()
+        .map(|ticket| {
+            serde_json::json!({
+                "id": ticket.id,
+                "resource_key": ticket.resource_key,
+                "title": ticket.title,
+                "workflow_state": ticket.workflow_state.as_str(),
+            })
+        })
+        .collect::<Vec<_>>();
+    let objectives = app
+        .objectives
+        .iter()
+        .map(|objective| {
+            serde_json::json!({
+                "id": objective.id,
+                "resource_key": objective.resource_key,
+                "title": objective.title,
+                "state": objective.state,
+            })
+        })
+        .collect::<Vec<_>>();
+    crate::e2e_observer::emit(
+        "backend_dashboard",
+        event,
+        serde_json::json!({
+            "workspace_id": app.workspace_id,
+            "focus": focus,
+            "selected_ticket_id": app.selected_ticket_id(),
+            "selected_objective_id": app.objectives.get(app.selected_objective).map(|objective| &objective.id),
+            "tickets": tickets,
+            "objectives": objectives,
+            "status": app.status,
+        }),
+    );
+}
+
 impl BackendDashboard {
     fn select_next(&mut self) {
         match self.focus {
diff --git a/crates/tui/src/e2e_observer.rs b/crates/tui/src/e2e_observer.rs
index 77eceb609..91a81a8e2 100644
--- a/crates/tui/src/e2e_observer.rs
+++ b/crates/tui/src/e2e_observer.rs
@@ -2,12 +2,11 @@ use std::fs::{File, OpenOptions};
 use std::io::Write;
 use std::path::PathBuf;
 use std::sync::{Mutex, OnceLock};
-use std::time::{Duration, SystemTime, UNIX_EPOCH};
+use std::time::{SystemTime, UNIX_EPOCH};
 
 use serde::Serialize;
 
 const EVENT_PATH_ENV: &str = "YOI_TUI_TEST_EVENTS";
-const HOLD_BACKGROUND_TASK_ENV: &str = "YOI_TUI_TEST_HOLD_BACKGROUND_TASK";
 
 static EVENT_WRITER: OnceLock<Option<Mutex<File>>> = OnceLock::new();
 
@@ -44,25 +43,6 @@ where
     }
 }
 
-pub(crate) async fn hold_background_task_if_requested(task: &'static str) {
-    let requested = std::env::var(HOLD_BACKGROUND_TASK_ENV).unwrap_or_default();
-    if !requested
-        .split(',')
-        .map(str::trim)
-        .any(|requested| requested == task)
-    {
-        return;
-    }
-    emit(
-        "panel",
-        "background_task_hold_started",
-        serde_json::json!({ "task": task }),
-    );
-    loop {
-        tokio::time::sleep(Duration::from_millis(25)).await;
-    }
-}
-
 fn open_event_writer() -> Option<Mutex<File>> {
     let path = std::env::var_os(EVENT_PATH_ENV).map(PathBuf::from)?;
     if let Some(parent) = path.parent() {
diff --git a/crates/worker-runtime/src/fs_store.rs b/crates/worker-runtime/src/fs_store.rs
index 731d97113..b97101201 100644
--- a/crates/worker-runtime/src/fs_store.rs
+++ b/crates/worker-runtime/src/fs_store.rs
@@ -140,25 +140,11 @@ impl FsRuntimeStore {
             })?;
         }
         let snapshot_exists = root.join(RUNTIME_FILE).is_file();
-        let workers_dir = root.join(WORKERS_DIR);
-        if !snapshot_exists
-            && workers_dir.is_dir()
-            && fs::read_dir(&workers_dir)
-                .map_err(|source| RuntimeError::StoreIo {
-                    operation: "inspect uninitialized runtime store",
-                    path: workers_dir.clone(),
-                    source,
-                })?
-                .next()
-                .is_some()
-        {
-            return Err(RuntimeError::StoreCorrupt {
-                operation: "open runtime store",
-                path: root,
-                message: "Worker records exist without a Runtime snapshot".to_string(),
-            });
+        if root_existed && !snapshot_exists {
+            validate_fresh_runtime_store_layout(&root)?;
         }
 
+        let workers_dir = root.join(WORKERS_DIR);
         fs::create_dir_all(&workers_dir).map_err(|source| RuntimeError::StoreIo {
             operation: "create runtime store",
             path: workers_dir,
@@ -362,6 +348,38 @@ impl FsRuntimeStore {
     }
 }
 
+fn validate_fresh_runtime_store_layout(root: &Path) -> Result<(), RuntimeError> {
+    let entries = fs::read_dir(root).map_err(|source| RuntimeError::StoreIo {
+        operation: "inspect uninitialized runtime store",
+        path: root.to_path_buf(),
+        source,
+    })?;
+    for entry in entries {
+        let entry = entry.map_err(|source| RuntimeError::StoreIo {
+            operation: "inspect uninitialized runtime store",
+            path: root.to_path_buf(),
+            source,
+        })?;
+        let file_type = entry.file_type().map_err(|source| RuntimeError::StoreIo {
+            operation: "inspect uninitialized runtime store entry",
+            path: entry.path(),
+            source,
+        })?;
+        if entry.file_name() == "auth.toml" && file_type.is_file() {
+            continue;
+        }
+        return Err(RuntimeError::StoreCorrupt {
+            operation: "open runtime store",
+            path: root.to_path_buf(),
+            message: format!(
+                "unexpected persistence `{}` exists without a Runtime snapshot",
+                entry.file_name().to_string_lossy()
+            ),
+        });
+    }
+    Ok(())
+}
+
 fn acquire_runtime_store_owner_lock(
     root: &Path,
 ) -> Result<Arc<RuntimeStoreOwnerLock>, RuntimeError> {
@@ -2173,6 +2191,41 @@ mod tests {
         );
     }
 
+    #[test]
+    fn snapshotless_directory_rejects_non_auth_persistence() {
+        for unexpected in ["events.jsonl", "unknown.json"] {
+            let parent = tempfile::tempdir().unwrap();
+            let root = parent.path().join("runtime");
+            fs::create_dir_all(&root).unwrap();
+            fs::write(root.join("auth.toml"), b"fixture auth material").unwrap();
+            fs::write(root.join(unexpected), b"must remain").unwrap();
+
+            let error = FsRuntimeStore::open_or_create(root.clone(), "runtime-test").unwrap_err();
+
+            assert!(matches!(
+                error,
+                RuntimeError::StoreCorrupt { path, .. } if path == root
+            ));
+            assert_eq!(fs::read(root.join(unexpected)).unwrap(), b"must remain");
+            assert!(!root.join(WORKERS_DIR).exists());
+        }
+    }
+
+    #[test]
+    fn orphan_archive_without_runtime_snapshot_is_rejected() {
+        let parent = tempfile::tempdir().unwrap();
+        let root = parent.path().join("runtime");
+        fs::create_dir_all(root.join(ORPHANED_WORKERS_DIR).join("worker-a")).unwrap();
+
+        let error = FsRuntimeStore::open_or_create(root.clone(), "runtime-test").unwrap_err();
+
+        assert!(matches!(
+            error,
+            RuntimeError::StoreCorrupt { path, .. } if path == root
+        ));
+        assert!(root.join(ORPHANED_WORKERS_DIR).join("worker-a").is_dir());
+    }
+
     #[test]
     fn worker_records_without_runtime_snapshot_are_rejected() {
         let parent = tempfile::tempdir().unwrap();
diff --git a/tests/e2e/src/lib.rs b/tests/e2e/src/lib.rs
index c8e5ff568..6719adbaa 100644
--- a/tests/e2e/src/lib.rs
+++ b/tests/e2e/src/lib.rs
@@ -628,6 +628,7 @@ impl PanelHarness {
 
         let mut command = Command::new(&config.binary);
         command
+            .current_dir(&config.workspace)
             .args(&config.command_args)
             .env_clear()
             .env("YOI_TUI_TEST_EVENTS", &artifacts.events_jsonl)
@@ -1338,8 +1339,8 @@ pub struct FixtureCleanupReport {
     pub report_path: PathBuf,
 }
 
-pub const READY_FIXTURE_TICKET_TITLE: &str = "Ready E2E Ticket";
-pub const PLANNING_FIXTURE_TICKET_TITLE: &str = "Planning E2E Ticket";
+pub const READY_FIXTURE_TICKET_TITLE: &str = "Planning E2E Ticket A";
+pub const PLANNING_FIXTURE_TICKET_TITLE: &str = "Planning E2E Ticket B";
 
 #[derive(Debug)]
 pub struct FixtureWorkspace {
@@ -1354,6 +1355,7 @@ pub struct FixtureWorkspace {
     pub artifacts_dir: PathBuf,
     pub ready_ticket_id: String,
     pub planning_ticket_id: String,
+    backend_environment: Option<WorkerE2eEnvironment>,
 }
 
 impl FixtureWorkspace {
@@ -1365,7 +1367,7 @@ impl FixtureWorkspace {
         Self::new_inner(binary, false)
     }
 
-    fn new_inner(binary: &Path, setup_dashboard: bool) -> Result<Self> {
+    fn new_inner(_binary: &Path, setup_dashboard: bool) -> Result<Self> {
         let allocation = allocate_fixture("tui")?;
         let root = allocation.root;
         let artifacts_dir = allocation.artifacts_dir;
@@ -1384,163 +1386,45 @@ impl FixtureWorkspace {
             artifacts_dir,
             ready_ticket_id: String::new(),
             planning_ticket_id: String::new(),
+            backend_environment: None,
         };
         fixture.write_fixture_metadata("created", None)?;
 
         if setup_dashboard {
-            let worker_metadata_root = active_worker_metadata_root(&fixture.home);
-            write_blocking_worker_metadata(&worker_metadata_root, "workspace")?;
-            write_blocking_worker_metadata(&worker_metadata_root, "workspace-orchestrator")?;
-            run_yoi(
-                binary,
-                &fixture.workspace,
-                &fixture.home,
-                &fixture.xdg_data_home,
-                &fixture.xdg_state_home,
-                &fixture.xdg_config_home,
-                &fixture.xdg_runtime_dir,
-                &fixture.artifacts_dir,
-                &["ticket", "init"],
-            )?;
-            let first = create_ticket(
-                binary,
-                &fixture.workspace,
-                &fixture.home,
-                &fixture.xdg_data_home,
-                &fixture.xdg_state_home,
-                &fixture.xdg_config_home,
-                &fixture.xdg_runtime_dir,
-                &fixture.artifacts_dir,
-                READY_FIXTURE_TICKET_TITLE,
-            )?;
-            run_yoi(
-                binary,
-                &fixture.workspace,
-                &fixture.home,
-                &fixture.xdg_data_home,
-                &fixture.xdg_state_home,
-                &fixture.xdg_config_home,
-                &fixture.xdg_runtime_dir,
-                &fixture.artifacts_dir,
-                &["ticket", "state", &first, "ready"],
-            )?;
-            let second = create_ticket(
-                binary,
-                &fixture.workspace,
-                &fixture.home,
-                &fixture.xdg_data_home,
-                &fixture.xdg_state_home,
-                &fixture.xdg_config_home,
-                &fixture.xdg_runtime_dir,
-                &fixture.artifacts_dir,
-                PLANNING_FIXTURE_TICKET_TITLE,
-            )?;
-            fixture.ready_ticket_id = first;
-            fixture.planning_ticket_id = second;
-            fixture.setup_orchestration_overlay(binary)?;
+            let mut backend = WorkerE2eEnvironment::new()?;
+            backend.start_backend()?;
+            backend.install_backend_token(&fixture.xdg_config_home)?;
+            fixture.ready_ticket_id = backend.create_planning_ticket(READY_FIXTURE_TICKET_TITLE)?;
+            fixture.planning_ticket_id =
+                backend.create_planning_ticket(PLANNING_FIXTURE_TICKET_TITLE)?;
+            backend.capture_panel_seed()?;
+            fixture.backend_environment = Some(backend);
         }
         fixture.write_fixture_metadata("ready", None)?;
         Ok(fixture)
     }
 
-    pub fn ready_fixture_ticket_row(&self) -> ExpectedPanelTicketRow {
-        ExpectedPanelTicketRow::new(
-            self.ready_ticket_id.clone(),
-            READY_FIXTURE_TICKET_TITLE,
-            "ready",
-        )
-        .with_action("Queue")
-        .with_local_state("ready")
-    }
-
-    pub fn ready_overlay_ticket_row(&self) -> ExpectedPanelTicketRow {
-        ExpectedPanelTicketRow::new(
-            self.ready_ticket_id.clone(),
-            READY_FIXTURE_TICKET_TITLE,
-            "ready→prog",
-        )
-        .with_action("Wait")
-        .with_disabled_reason("orchestration worktree overlay shows Ticket state inprogress")
-        .with_local_state("ready")
-        .with_overlay_state("inprogress")
-    }
-
-    pub fn planning_fixture_ticket_row(&self) -> ExpectedPanelTicketRow {
-        ExpectedPanelTicketRow::new(
-            self.planning_ticket_id.clone(),
-            PLANNING_FIXTURE_TICKET_TITLE,
-            "planning",
-        )
-        .with_action("Clarify")
-        .with_disabled_reason("Ticket is still in planning")
-        .with_local_state("planning")
-    }
-
-    pub fn expected_dashboard_content(&self) -> ExpectedDashboardContent {
-        ExpectedDashboardContent {
-            tickets: vec![
-                self.ready_overlay_ticket_row(),
-                self.planning_fixture_ticket_row(),
-            ],
-            worker_names: vec!["workspace".to_string()],
-            companion_status: "spawned".to_string(),
-            orchestrator_status: "unavailable".to_string(),
-        }
-    }
-
-    fn setup_orchestration_overlay(&self, binary: &Path) -> Result<()> {
-        run_git(&self.workspace, &["init"])?;
-        run_git(&self.workspace, &["checkout", "-B", "develop"])?;
-        run_git(
-            &self.workspace,
-            &["config", "user.email", "fixture@example.invalid"],
-        )?;
-        run_git(&self.workspace, &["config", "user.name", "Yoi E2E Fixture"])?;
-        run_git(&self.workspace, &["add", ".yoi"])?;
-        run_git(&self.workspace, &["commit", "-m", "fixture tickets"])?;
-        let orchestration = self.workspace.join(".worktree/orchestration");
-        run_git(
-            &self.workspace,
-            &[
-                "worktree",
-                "add",
-                "-b",
-                "orchestration",
-                orchestration.to_string_lossy().as_ref(),
-                "HEAD",
-            ],
-        )?;
-        run_yoi(
-            binary,
-            &orchestration,
-            &self.home,
-            &self.xdg_data_home,
-            &self.xdg_state_home,
-            &self.xdg_config_home,
-            &self.xdg_runtime_dir,
-            &self.artifacts_dir,
-            &["ticket", "state", &self.ready_ticket_id, "queued"],
-        )?;
-        run_yoi(
-            binary,
-            &orchestration,
-            &self.home,
-            &self.xdg_data_home,
-            &self.xdg_state_home,
-            &self.xdg_config_home,
-            &self.xdg_runtime_dir,
-            &self.artifacts_dir,
-            &["ticket", "state", &self.ready_ticket_id, "inprogress"],
-        )?;
-        run_git(&orchestration, &["add", ".yoi"])?;
-        run_git(
-            &orchestration,
-            &["commit", "-m", "fixture orchestration overlay"],
-        )?;
-        Ok(())
+    pub fn backend_target(&self) -> Option<(&str, &str)> {
+        self.backend_environment
+            .as_ref()
+            .and_then(|backend| backend.backend_target().ok())
     }
 
     pub fn panel_config(&self, binary: PathBuf) -> PanelHarnessConfig {
+        let command_args = if let Some(backend) = self.backend_environment.as_ref() {
+            let (server_url, workspace_id) = backend
+                .backend_target()
+                .expect("started Backend panel fixture has a target");
+            vec![
+                "--backend".to_string(),
+                server_url.to_string(),
+                "--workspace-id".to_string(),
+                workspace_id.to_string(),
+                "panel".to_string(),
+            ]
+        } else {
+            Vec::new()
+        };
         PanelHarnessConfig {
             binary,
             workspace: self.workspace.clone(),
@@ -1553,11 +1437,7 @@ impl FixtureWorkspace {
             terminal_size: (100, 32),
             hold_background_task: None,
             rewind_fixture: false,
-            command_args: vec![
-                "panel".to_string(),
-                "--workspace".to_string(),
-                self.workspace.display().to_string(),
-            ],
+            command_args,
             artifacts_dir: self.artifacts_dir.clone(),
         }
     }
@@ -1590,18 +1470,34 @@ impl FixtureWorkspace {
     }
 
     fn cleanup_inner(&mut self, strict: bool) -> Result<FixtureCleanupReport> {
+        let mut cleanup_errors = Vec::new();
+        let token_path = self.xdg_config_home.join("yoi/backend-tokens.json");
+        match fs::remove_file(&token_path) {
+            Ok(()) => {}
+            Err(error) if error.kind() == io::ErrorKind::NotFound => {}
+            Err(error) => cleanup_errors.push(format!(
+                "remove Backend client credential {}: {error}",
+                token_path.display()
+            )),
+        }
+        if let Some(backend) = self.backend_environment.take()
+            && let Err(error) = backend.cleanup()
+        {
+            cleanup_errors.push(format!("cleanup Backend panel environment: {error}"));
+        }
+
         let snapshot_dir = self.artifacts_dir.join("fixture-snapshot");
         if snapshot_dir.exists() {
             fs::remove_dir_all(&snapshot_dir)?;
         }
         copy_dir_recursive(&self.root, &snapshot_dir)?;
 
-        let mut cleanup_error = None;
-        if let Some(temp_root) = self.temp_root.take() {
-            if let Err(err) = temp_root.close() {
-                cleanup_error = Some(err.to_string());
-            }
+        if let Some(temp_root) = self.temp_root.take()
+            && let Err(err) = temp_root.close()
+        {
+            cleanup_errors.push(err.to_string());
         }
+        let cleanup_error = (!cleanup_errors.is_empty()).then(|| cleanup_errors.join("; "));
         let fixture_root_exists_after = self.root.exists();
         let cleanup_success = cleanup_error.is_none() && !fixture_root_exists_after;
         let report = FixtureCleanupReport {
@@ -1648,7 +1544,7 @@ impl FixtureWorkspace {
                     "ready": {
                         "id": &self.ready_ticket_id,
                         "title": READY_FIXTURE_TICKET_TITLE,
-                        "state": "ready"
+                        "state": "planning"
                     },
                     "planning": {
                         "id": &self.planning_ticket_id,
@@ -1661,8 +1557,10 @@ impl FixtureWorkspace {
                     "host_runtime_inherited": false,
                     "host_xdg_runtime_dir_present": std::env::var_os("XDG_RUNTIME_DIR").is_some(),
                     "tested_yoi_runtime_source": "fixture XDG_RUNTIME_DIR",
-                    "tested_yoi_worker_allocation": self.xdg_runtime_dir.join("yoi").join("workers.json"),
-                    "fixture_worker_metadata_root": active_worker_metadata_root(&self.home)
+                    "backend_target": self.backend_target().map(|(base_url, workspace_id)| serde_json::json!({
+                        "base_url": base_url,
+                        "workspace_id": workspace_id,
+                    })),
                 },
                 "tested_yoi_env_policy": tested_yoi_env_policy_overview(),
                 "cleanup": cleanup,
@@ -1873,145 +1771,6 @@ fn open_pty(size: (u16, u16)) -> Result<(File, File)> {
     Ok((master, slave))
 }
 
-fn create_ticket(
-    binary: &Path,
-    workspace: &Path,
-    home: &Path,
-    data: &Path,
-    state: &Path,
-    config: &Path,
-    runtime: &Path,
-    artifacts_dir: &Path,
-    title: &str,
-) -> Result<String> {
-    let output = run_yoi_capture(
-        binary,
-        workspace,
-        home,
-        data,
-        state,
-        config,
-        runtime,
-        artifacts_dir,
-        &["ticket", "create", "--title", title],
-    )?;
-    output
-        .split_whitespace()
-        .find(|part| part.len() >= 13 && part.chars().all(|ch| ch.is_ascii_alphanumeric()))
-        .map(ToOwned::to_owned)
-        .ok_or_else(|| HarnessError::Protocol(format!("could not parse ticket id from {output:?}")))
-}
-
-fn run_git(workspace: &Path, args: &[&str]) -> Result<()> {
-    let output = Command::new("git")
-        .args(args)
-        .current_dir(workspace)
-        .output()?;
-    if output.status.success() {
-        return Ok(());
-    }
-    Err(HarnessError::CommandFailed {
-        program: PathBuf::from("git"),
-        args: args.iter().map(|arg| (*arg).to_string()).collect(),
-        status: output.status,
-        stdout: String::from_utf8_lossy(&output.stdout).into_owned(),
-        stderr: String::from_utf8_lossy(&output.stderr).into_owned(),
-    })
-}
-
-fn run_yoi(
-    binary: &Path,
-    workspace: &Path,
-    home: &Path,
-    data: &Path,
-    state: &Path,
-    config: &Path,
-    runtime: &Path,
-    artifacts_dir: &Path,
-    args: &[&str],
-) -> Result<()> {
-    let output = run_yoi_capture(
-        binary,
-        workspace,
-        home,
-        data,
-        state,
-        config,
-        runtime,
-        artifacts_dir,
-        args,
-    )?;
-    drop(output);
-    Ok(())
-}
-
-fn run_yoi_capture(
-    binary: &Path,
-    workspace: &Path,
-    home: &Path,
-    data: &Path,
-    state: &Path,
-    config: &Path,
-    runtime: &Path,
-    artifacts_dir: &Path,
-    args: &[&str],
-) -> Result<String> {
-    let env_policy = fixture_setup_env_policy();
-    append_fixture_command_artifact(artifacts_dir, workspace, binary, args, &env_policy)?;
-
-    let mut command = Command::new(binary);
-    command
-        .args(args)
-        .current_dir(workspace)
-        .env_clear()
-        .env("HOME", home)
-        .env("XDG_DATA_HOME", data)
-        .env("XDG_STATE_HOME", state)
-        .env("XDG_CONFIG_HOME", config)
-        .env("XDG_RUNTIME_DIR", runtime)
-        .env("YOI_POD_RUNTIME_COMMAND", binary);
-
-    let output = command.output()?;
-    if !output.status.success() {
-        return Err(HarnessError::CommandFailed {
-            program: binary.to_path_buf(),
-            args: args.iter().map(|arg| (*arg).to_owned()).collect(),
-            status: output.status,
-            stdout: String::from_utf8_lossy(&output.stdout).into_owned(),
-            stderr: String::from_utf8_lossy(&output.stderr).into_owned(),
-        });
-    }
-    let mut text = String::from_utf8_lossy(&output.stdout).into_owned();
-    text.push_str(&String::from_utf8_lossy(&output.stderr));
-    Ok(text)
-}
-
-fn append_fixture_command_artifact(
-    artifacts_dir: &Path,
-    workspace: &Path,
-    binary: &Path,
-    args: &[&str],
-    env_policy: &EnvPolicy,
-) -> Result<()> {
-    fs::create_dir_all(artifacts_dir)?;
-    let mut file = OpenOptions::new()
-        .append(true)
-        .create(true)
-        .open(artifacts_dir.join("fixture-commands.jsonl"))?;
-    serde_json::to_writer(
-        &mut file,
-        &serde_json::json!({
-            "ts_ms": now_ms(),
-            "binary": binary,
-            "workspace": workspace,
-            "args": args,
-            "tested_yoi_env_policy": env_policy,
-        }),
-    )?;
-    writeln!(file)?;
-    Ok(())
-}
-
 fn copy_dir_recursive(source: &Path, destination: &Path) -> Result<()> {
     if !source.exists() {
         return Ok(());
@@ -2037,17 +1796,6 @@ fn copy_dir_recursive(source: &Path, destination: &Path) -> Result<()> {
     Ok(())
 }
 
-fn active_worker_metadata_root(home: &Path) -> PathBuf {
-    home.join(".yoi").join("workers")
-}
-
-fn write_blocking_worker_metadata(worker_metadata_root: &Path, worker_name: &str) -> Result<()> {
-    let dir = worker_metadata_root.join(worker_name);
-    fs::create_dir_all(&dir)?;
-    fs::write(dir.join("metadata.json"), b"not valid metadata for e2e\n")?;
-    Ok(())
-}
-
 fn output_has_enabled_mouse_capture(output: &[u8]) -> bool {
     mouse_mode_enabled(output, b"\x1b[?1000h", b"\x1b[?1000l")
         && mouse_mode_enabled(output, b"\x1b[?1006h", b"\x1b[?1006l")
diff --git a/tests/e2e/src/worker_environment.rs b/tests/e2e/src/worker_environment.rs
index fb92b1fbb..ec60d7078 100644
--- a/tests/e2e/src/worker_environment.rs
+++ b/tests/e2e/src/worker_environment.rs
@@ -263,6 +263,8 @@ impl WorkerE2eEnvironment {
             serde_json::to_vec_pretty(&binaries)?,
         )?;
         let client = Client::builder()
+            .no_proxy()
+            .redirect(reqwest::redirect::Policy::none())
             .connect_timeout(Duration::from_secs(1))
             .timeout(Duration::from_secs(3))
             .build()
@@ -295,6 +297,11 @@ impl WorkerE2eEnvironment {
     }
 
     pub fn start(&mut self) -> Result<()> {
+        self.start_backend()?;
+        self.start_runtime()
+    }
+
+    pub fn start_backend(&mut self) -> Result<()> {
         assert_absent_or_empty(&self.server_data_dir, "Server data directory")?;
         assert_absent_or_empty(&self.runtime_data_dir, "Runtime data directory")?;
         let server_binary = self.binaries.binary("yoi-server")?;
@@ -369,7 +376,14 @@ impl WorkerE2eEnvironment {
         })?;
         let bundle_path = self.root.join("workspace-public-identity.json");
         fs::write(&bundle_path, serde_json::to_vec_pretty(&public_bundle)?)?;
+        self.write_metadata("backend-running")?;
+        Ok(())
+    }
 
+    fn start_runtime(&mut self) -> Result<()> {
+        let bundle_path = self.root.join("workspace-public-identity.json");
+        let server_url = self.required_server_url()?.to_string();
+        let workspace_id = self.required_workspace_id()?.to_string();
         let runtime_binary = self.binaries.binary("yoi-runtime")?;
         self.run_command(
             &runtime_binary,
@@ -501,6 +515,91 @@ impl WorkerE2eEnvironment {
         Ok(())
     }
 
+    pub fn install_backend_token(&self, config_home: &Path) -> Result<PathBuf> {
+        let server_url = self.required_server_url()?;
+        let access_token = self.access_token.as_deref().ok_or_else(|| {
+            HarnessError::Protocol("Backend access token is not initialized".to_string())
+        })?;
+        let token_path = config_home.join("yoi/backend-tokens.json");
+        if let Some(parent) = token_path.parent() {
+            fs::create_dir_all(parent)?;
+        }
+        fs::write(
+            &token_path,
+            serde_json::to_vec_pretty(&serde_json::json!({
+                "tokens": {
+                    server_url: {
+                        "token_type": "Bearer",
+                        "access_token": access_token,
+                    }
+                }
+            }))?,
+        )?;
+        #[cfg(unix)]
+        {
+            use std::os::unix::fs::PermissionsExt;
+            fs::set_permissions(&token_path, fs::Permissions::from_mode(0o600))?;
+        }
+        Ok(token_path)
+    }
+
+    pub fn create_planning_ticket(&self, title: &str) -> Result<String> {
+        let server_url = self.required_server_url()?;
+        let workspace_id = self.required_workspace_id()?;
+        let created = self.request_json(
+            self.client
+                .post(format!("{server_url}/api/w/{workspace_id}/tickets"))
+                .json(&serde_json::json!({
+                    "title": title,
+                    "slug": null,
+                    "kind": "task",
+                    "priority": "P2",
+                    "labels": [],
+                    "body": "Backend-owned panel E2E fixture.",
+                    "author": null,
+                    "assignee": null,
+                    "readiness": null,
+                    "risk_flags": [],
+                    "workflow_state": "planning",
+                    "queued_by": null,
+                    "queued_at": null,
+                    "repository_key": null,
+                    "ref_selector": null,
+                })),
+            "create Ticket",
+        )?;
+        json_string(&created, "/id")
+    }
+
+    pub fn capture_panel_seed(&self) -> Result<()> {
+        let server_url = self.required_server_url()?;
+        let workspace_id = self.required_workspace_id()?;
+        let tickets = self.request_json(
+            self.client.get(format!(
+                "{server_url}/api/w/{workspace_id}/tickets/search?state=active"
+            )),
+            "list panel fixture Tickets",
+        )?;
+        let objectives = self.request_json(
+            self.client.get(format!(
+                "{server_url}/api/w/{workspace_id}/objectives?limit=1000"
+            )),
+            "list panel fixture Objectives",
+        )?;
+        fs::write(
+            self.artifacts_dir.join("panel-seed.json"),
+            serde_json::to_vec_pretty(&serde_json::json!({
+                "tickets": tickets,
+                "objectives": objectives,
+            }))?,
+        )?;
+        Ok(())
+    }
+
+    pub fn backend_target(&self) -> Result<(&str, &str)> {
+        Ok((self.required_server_url()?, self.required_workspace_id()?))
+    }
+
     pub fn server_port(&self) -> Result<u16> {
         url_port(self.required_server_url()?)
     }
@@ -652,7 +751,12 @@ impl WorkerE2eEnvironment {
                 "binary": binary,
                 "args": args,
                 "status": output.status.code(),
-                "stdout": if redact_stdout { "<redacted>" } else { "captured-not-persisted" },
+                "stdout": if redact_stdout {
+                    "<redacted>".to_string()
+                } else {
+                    bounded_text(&output.stdout, MAX_COMMAND_OUTPUT_BYTES)
+                },
+                "stderr": bounded_text(&output.stderr, MAX_COMMAND_OUTPUT_BYTES),
                 "env_clear": true,
             }),
         )?;
diff --git a/tests/e2e/tests/panel.rs b/tests/e2e/tests/panel.rs
index bed46db28..058e27827 100644
--- a/tests/e2e/tests/panel.rs
+++ b/tests/e2e/tests/panel.rs
@@ -1,663 +1,198 @@
+use std::fs;
 use std::time::{Duration, Instant};
 
+use serde_json::Value;
+use yoi_e2e::{FixtureCleanupReport, FixtureWorkspace, KeyPress, PanelHarness, yoi_binary};
+
 const FIRST_VISIBLE_RENDER_BUDGET: Duration = Duration::from_millis(1500);
 const DASHBOARD_CONTENT_READY_BUDGET: Duration = Duration::from_secs(5);
 
-use yoi_e2e::{
-    DashboardCompanionState, DashboardContentCategories, DashboardContentReady, DashboardHeader,
-    DashboardOrchestratorState, DashboardSnapshot, ExpectedDashboardContent,
-    ExpectedPanelTicketRow, FixtureCleanupReport, FixtureWorkspace, KeyPress, PanelHarness,
-    PanelRect, PanelRowKey, RenderedPanelRow, RowsRendered, yoi_binary,
-};
-
-fn rendered_ticket_row(
-    id: &str,
-    title: &str,
-    status: &str,
-    action: Option<&str>,
-    disabled_reason: Option<&str>,
-    local_state: Option<&str>,
-    overlay_state: Option<&str>,
-) -> RenderedPanelRow {
-    RenderedPanelRow {
-        key: PanelRowKey {
-            kind: "ticket".to_string(),
-            id: id.to_string(),
-        },
-        title: title.to_string(),
-        status: Some(status.to_string()),
-        action: action.map(ToOwned::to_owned),
-        disabled_reason: disabled_reason.map(ToOwned::to_owned),
-        local_state: local_state.map(ToOwned::to_owned),
-        overlay_state: overlay_state.map(ToOwned::to_owned),
-        overlay_detail: overlay_state.map(|state| format!("orchestration:{state}")),
-        rect: PanelRect {
-            x: 0,
-            y: 0,
-            width: 10,
-            height: 1,
-        },
-    }
-}
-
-fn rendered_worker_row(name: &str) -> RenderedPanelRow {
-    RenderedPanelRow {
-        key: PanelRowKey {
-            kind: "worker".to_string(),
-            id: name.to_string(),
-        },
-        title: name.to_string(),
-        status: None,
-        action: None,
-        disabled_reason: None,
-        local_state: None,
-        overlay_state: None,
-        overlay_detail: None,
-        rect: PanelRect {
-            x: 0,
-            y: 1,
-            width: 10,
-            height: 1,
-        },
-    }
-}
-
-fn ready_snapshot(rows: Vec<RenderedPanelRow>) -> DashboardContentReady {
-    DashboardContentReady {
-        snapshot: DashboardSnapshot {
-            header: DashboardHeader {
-                ticket_configured: true,
-                companion: Some(DashboardCompanionState {
-                    worker_name: "workspace".to_string(),
-                    status: "unavailable".to_string(),
-                }),
-                orchestrator: Some(DashboardOrchestratorState {
-                    worker_name: "workspace-orchestrator".to_string(),
-                    status: "unavailable".to_string(),
-                    detail: Some("fixture blocks host Worker launch".to_string()),
-                }),
-                diagnostics: vec![],
-            },
-            rows,
-        },
-        categories: DashboardContentCategories {
-            ticket_rows: 2,
-            ready_ticket_rows: 1,
-            planning_ticket_rows: 1,
-            worker_rows: 1,
-            actionable_rows: 2,
-        },
-    }
-}
-
 #[test]
-fn panel_fixture_ticket_row_matcher_rejects_absent_fixture_data() {
-    let expected = ExpectedPanelTicketRow::new("0000000000000", "Ready E2E Ticket", "ready")
-        .with_action("Queue")
-        .with_local_state("ready");
-    let wrong_title = rendered_ticket_row(
-        "0000000000000",
-        "Different Ticket",
-        "ready",
-        Some("Queue"),
-        None,
-        Some("ready"),
-        None,
-    );
-    let wrong_kind = RenderedPanelRow {
-        key: PanelRowKey {
-            kind: "worker".to_string(),
-            id: "0000000000000".to_string(),
-        },
-        title: "Ready E2E Ticket".to_string(),
-        status: Some("ready".to_string()),
-        action: Some("Queue".to_string()),
-        disabled_reason: None,
-        local_state: Some("ready".to_string()),
-        overlay_state: None,
-        overlay_detail: None,
-        rect: PanelRect {
-            x: 0,
-            y: 0,
-            width: 10,
-            height: 1,
-        },
-    };
-
-    assert!(!expected.matches(&wrong_title));
-    assert!(!expected.matches(&wrong_kind));
-    let rows = RowsRendered {
-        selected: None,
-        rows: vec![wrong_title, wrong_kind],
-    };
-    assert!(!rows.has_fixture_ticket_row(&expected));
-}
-
-#[test]
-fn dashboard_snapshot_rejects_missing_row_wrong_state_missing_overlay_and_missing_action() {
-    let expected_ready = ExpectedPanelTicketRow::new("ready-id", "Ready E2E Ticket", "ready→prog")
-        .with_action("Wait")
-        .with_disabled_reason("orchestration worktree overlay shows Ticket state inprogress")
-        .with_local_state("ready")
-        .with_overlay_state("inprogress");
-    let expected_planning =
-        ExpectedPanelTicketRow::new("planning-id", "Planning E2E Ticket", "planning")
-            .with_action("Clarify")
-            .with_disabled_reason("Ticket is still in planning")
-            .with_local_state("planning");
-    let expected = ExpectedDashboardContent {
-        tickets: vec![expected_ready.clone(), expected_planning.clone()],
-        worker_names: vec!["workspace".to_string()],
-        companion_status: "unavailable".to_string(),
-        orchestrator_status: "unavailable".to_string(),
-    };
-    let complete_rows = || {
-        vec![
-            rendered_ticket_row(
-                "ready-id",
-                "Ready E2E Ticket",
-                "ready→prog",
-                Some("Wait"),
-                Some("orchestration worktree overlay shows Ticket state inprogress"),
-                Some("ready"),
-                Some("inprogress"),
-            ),
-            rendered_ticket_row(
-                "planning-id",
-                "Planning E2E Ticket",
-                "planning",
-                Some("Clarify"),
-                Some("Ticket is still in planning"),
-                Some("planning"),
-                None,
-            ),
-            rendered_worker_row("workspace"),
-        ]
-    };
-    assert_eq!(
-        ready_snapshot(complete_rows()).snapshot_for_expected(&expected),
-        expected.snapshot()
-    );
-
-    let missing_row = ready_snapshot(vec![
-        rendered_ticket_row(
-            "ready-id",
-            "Ready E2E Ticket",
-            "ready→prog",
-            Some("Wait"),
-            Some("orchestration worktree overlay shows Ticket state inprogress"),
-            Some("ready"),
-            Some("inprogress"),
-        ),
-        rendered_worker_row("workspace"),
-    ]);
-    assert_ne!(
-        missing_row.snapshot_for_expected(&expected),
-        expected.snapshot()
-    );
-
-    let mut wrong_state_rows = complete_rows();
-    wrong_state_rows[0].status = Some("ready".to_string());
-    assert_ne!(
-        ready_snapshot(wrong_state_rows).snapshot_for_expected(&expected),
-        expected.snapshot()
-    );
-
-    let mut missing_overlay_rows = complete_rows();
-    missing_overlay_rows[0].overlay_state = None;
-    assert_ne!(
-        ready_snapshot(missing_overlay_rows).snapshot_for_expected(&expected),
-        expected.snapshot()
-    );
-
-    let mut missing_action_rows = complete_rows();
-    missing_action_rows[0].action = None;
-    assert_ne!(
-        ready_snapshot(missing_action_rows).snapshot_for_expected(&expected),
-        expected.snapshot()
-    );
-}
-
-#[test]
-fn panel_first_visible_render_arrives_before_background_reload() -> yoi_e2e::Result<()> {
+fn backend_panel_loads_backend_owned_tickets_and_supports_reload_navigation_and_ctrl_c()
+-> yoi_e2e::Result<()> {
     let binary = yoi_binary()?;
     let fixture = FixtureWorkspace::new(&binary)?;
-    assert_fixture_paths_are_isolated(&fixture);
-    let ready_ticket = fixture.ready_fixture_ticket_row();
-
-    let started = Instant::now();
-    let mut panel =
-        PanelHarness::spawn(fixture.panel_config_holding_background_task(binary, "reload"))?;
-    let remaining = FIRST_VISIBLE_RENDER_BUDGET
-        .checked_sub(started.elapsed())
-        .unwrap_or_else(|| Duration::from_millis(0));
-    panel.wait_for_first_visible_frame(remaining)?;
-    let first_visible_elapsed = started.elapsed();
-    eprintln!(
-        "panel first visible frame: {first_visible_elapsed:?} (budget {FIRST_VISIBLE_RENDER_BUDGET:?}); artifacts at {}",
-        panel.artifacts().dir.display()
-    );
-    assert!(
-        first_visible_elapsed <= FIRST_VISIBLE_RENDER_BUDGET,
-        "first visible frame took {first_visible_elapsed:?}, budget {FIRST_VISIBLE_RENDER_BUDGET:?}; artifacts at {}",
-        panel.artifacts().dir.display()
-    );
-
-    let events = panel.events()?;
-    let ready_index = events
-        .iter()
-        .position(|event| event.event == "panel_ready")
-        .expect("panel_ready event should be present");
-    assert!(
-        events[..ready_index]
-            .iter()
-            .all(|event| event.event != "background_task_started"),
-        "initial frame must be emitted before reload/background work starts; artifacts at {}",
-        panel.artifacts().dir.display()
-    );
-
-    panel.expect_background_task_pending("reload")?;
-    let events = panel.events()?;
-    let reload_started_index = events
-        .iter()
-        .position(|event| {
-            event.event == "background_task_started"
-                && event.data.get("task").and_then(serde_json::Value::as_str) == Some("reload")
-        })
-        .expect("held reload should start after first visible frame");
-    assert!(
-        ready_index < reload_started_index,
-        "first visible frame and reload ordering should remain separate; artifacts at {}",
-        panel.artifacts().dir.display()
-    );
-    panel.assert_fixture_ticket_row_not_rendered(&ready_ticket, Duration::from_millis(150))?;
-
-    panel.press(KeyPress::CtrlC)?;
-    let status = panel.expect_exit_within(PanelHarness::default_exit_wait())?;
-    assert!(status.success(), "panel should exit cleanly with Ctrl+C");
-    drop(panel);
-    assert_fixture_cleanup(fixture.cleanup()?);
-    Ok(())
-}
-
-#[test]
-fn panel_dashboard_content_ready_has_startup_budget() -> yoi_e2e::Result<()> {
-    let binary = yoi_binary()?;
-    let fixture = FixtureWorkspace::new(&binary)?;
-    assert_fixture_paths_are_isolated(&fixture);
-    let expected_content = fixture.expected_dashboard_content();
+    assert_backend_fixture_is_isolated(&fixture);
+    let ready_ticket_id = fixture.ready_ticket_id.clone();
+    let planning_ticket_id = fixture.planning_ticket_id.clone();
+    let (_, workspace_id) = fixture
+        .backend_target()
+        .expect("panel fixture should own a Backend target");
+    let workspace_id = workspace_id.to_string();
 
     let started = Instant::now();
     let mut panel = PanelHarness::spawn(fixture.panel_config(binary))?;
-    let first_visible_remaining = FIRST_VISIBLE_RENDER_BUDGET
-        .checked_sub(started.elapsed())
-        .unwrap_or_else(|| Duration::from_millis(0));
-    panel.wait_for_first_visible_frame(first_visible_remaining)?;
+    panel.wait_for_first_visible_frame(FIRST_VISIBLE_RENDER_BUDGET)?;
     let first_visible_elapsed = started.elapsed();
-    eprintln!(
-        "panel first visible frame: {first_visible_elapsed:?} (budget {FIRST_VISIBLE_RENDER_BUDGET:?}); artifacts at {}",
-        panel.artifacts().dir.display()
-    );
     assert!(
         first_visible_elapsed <= FIRST_VISIBLE_RENDER_BUDGET,
-        "first visible frame took {first_visible_elapsed:?}, budget {FIRST_VISIBLE_RENDER_BUDGET:?}; artifacts at {}",
+        "first visible Backend panel frame took {first_visible_elapsed:?}, budget {FIRST_VISIBLE_RENDER_BUDGET:?}; artifacts at {}",
         panel.artifacts().dir.display()
     );
 
-    let content_ready_remaining = DASHBOARD_CONTENT_READY_BUDGET
-        .checked_sub(started.elapsed())
-        .unwrap_or_else(|| Duration::from_millis(0));
-    let content_ready =
-        panel.wait_for_dashboard_content_ready(&expected_content, content_ready_remaining)?;
-    assert!(
-        content_ready.snapshot.header.ticket_configured,
-        "dashboard content ready must include usable Ticket configuration; artifacts at {}",
-        panel.artifacts().dir.display()
-    );
-    assert!(
-        content_ready.snapshot.header.companion.is_some()
-            && content_ready.snapshot.header.orchestrator.is_some(),
-        "dashboard content ready must include Companion and Orchestrator header status; got {:?}; artifacts at {}",
-        content_ready.snapshot.header,
-        panel.artifacts().dir.display()
-    );
+    let ready = panel.wait_for(
+        "Backend dashboard content ready with fixture Tickets",
+        DASHBOARD_CONTENT_READY_BUDGET,
+        |event| {
+            event.event == "backend_dashboard_content_ready"
+                && event.data.get("workspace_id").and_then(Value::as_str)
+                    == Some(workspace_id.as_str())
+                && has_backend_ticket(
+                    &event.data,
+                    &ready_ticket_id,
+                    "Planning E2E Ticket A",
+                    "planning",
+                )
+                && has_backend_ticket(
+                    &event.data,
+                    &planning_ticket_id,
+                    "Planning E2E Ticket B",
+                    "planning",
+                )
+        },
+    )?;
     assert_eq!(
-        content_ready.snapshot_for_expected(&expected_content),
-        expected_content.snapshot(),
-        "dashboard content ready must match expected Ticket/action/overlay/header snapshot; artifacts at {}",
-        panel.artifacts().dir.display()
+        ready.data.get("focus").and_then(Value::as_str),
+        Some("tickets")
     );
     assert!(
-        content_ready.categories.ready_ticket_rows > 0
-            && content_ready.categories.planning_ticket_rows > 0
-            && content_ready.categories.worker_rows > 0,
-        "dashboard content ready must include ready Ticket, planning Ticket, and Worker categories; got {:?}; artifacts at {}",
-        content_ready.categories,
-        panel.artifacts().dir.display()
-    );
-    let content_ready_elapsed = started.elapsed();
-    eprintln!(
-        "panel dashboard content ready: {content_ready_elapsed:?} (budget {DASHBOARD_CONTENT_READY_BUDGET:?}; first frame {first_visible_elapsed:?}); artifacts at {}",
-        panel.artifacts().dir.display()
-    );
-    assert!(
-        content_ready_elapsed <= DASHBOARD_CONTENT_READY_BUDGET,
-        "dashboard content ready took {content_ready_elapsed:?}, budget {DASHBOARD_CONTENT_READY_BUDGET:?}; artifacts at {}",
+        started.elapsed() <= DASHBOARD_CONTENT_READY_BUDGET,
+        "Backend dashboard content missed startup budget; artifacts at {}",
         panel.artifacts().dir.display()
     );
 
-    let source_breakdown = panel.expect_dashboard_source_breakdown()?;
-    assert!(
-        source_breakdown.has_source("pod_metadata_status_probe.initial")
-            && source_breakdown.has_source("ticket_config_probe")
-            && source_breakdown.has_source("local_claim_scan")
-            && source_breakdown.has_source("ticket_scan_parse")
-            && source_breakdown.has_source("orchestration_overlay_validation_read_git")
-            && source_breakdown.has_source("workspace_panel.build.total"),
-        "dashboard source breakdown should include worker metadata/status, ticket scan/parse, overlay validation/read/git, local claim scan, and panel-build sources; got {:?}; artifacts at {}",
-        source_breakdown,
-        panel.artifacts().dir.display()
-    );
-    eprintln!(
-        "panel dashboard source breakdown: {:?}; artifacts at {}",
-        source_breakdown,
-        panel.artifacts().dir.display()
-    );
+    panel.press(KeyPress::Text("j".to_string()))?;
+    panel.wait_for(
+        "Backend dashboard Ticket selection change",
+        Duration::from_secs(2),
+        |event| {
+            event.event == "backend_dashboard_selection_changed"
+                && event.data.get("selected_ticket_id").and_then(Value::as_str)
+                    == Some(planning_ticket_id.as_str())
+        },
+    )?;
+
+    panel.press(KeyPress::Text("r".to_string()))?;
+    panel.wait_for(
+        "Backend dashboard reload",
+        Duration::from_secs(2),
+        |event| {
+            event.event == "backend_dashboard_reloaded"
+                && has_backend_ticket(
+                    &event.data,
+                    &ready_ticket_id,
+                    "Planning E2E Ticket A",
+                    "planning",
+                )
+                && has_backend_ticket(
+                    &event.data,
+                    &planning_ticket_id,
+                    "Planning E2E Ticket B",
+                    "planning",
+                )
+        },
+    )?;
 
     panel.press(KeyPress::CtrlC)?;
     let status = panel.expect_exit_within(PanelHarness::default_exit_wait())?;
-    assert!(status.success(), "panel should exit cleanly with Ctrl+C");
+    assert!(
+        status.success(),
+        "Backend panel should exit cleanly with Ctrl+C"
+    );
+    assert!(
+        panel
+            .events()?
+            .iter()
+            .any(|event| event.event == "quit_requested")
+    );
     drop(panel);
-    assert_fixture_cleanup(fixture.cleanup()?);
+
+    let report = fixture.cleanup()?;
+    assert_fixture_cleanup(&report);
+    assert!(
+        !report
+            .snapshot_dir
+            .join("config/yoi/backend-tokens.json")
+            .exists(),
+        "Backend credential must be removed before fixture snapshot"
+    );
     Ok(())
 }
 
 #[test]
-fn panel_dashboard_content_ready_from_shell_enter_path() -> yoi_e2e::Result<()> {
+fn backend_panel_shell_enter_path_uses_the_same_backend_authority() -> yoi_e2e::Result<()> {
     let binary = yoi_binary()?;
     let fixture = FixtureWorkspace::new(&binary)?;
-    assert_fixture_paths_are_isolated(&fixture);
-    let expected_content = fixture.expected_dashboard_content();
+    assert_backend_fixture_is_isolated(&fixture);
+    let ready_ticket_id = fixture.ready_ticket_id.clone();
 
     let (mut panel, started) = PanelHarness::spawn_via_shell_enter(fixture.panel_config(binary))?;
-    let first_visible_remaining = FIRST_VISIBLE_RENDER_BUDGET
-        .checked_sub(started.elapsed())
-        .unwrap_or_else(|| Duration::from_millis(0));
-    panel.wait_for_first_visible_frame(first_visible_remaining)?;
-    let first_visible_elapsed = started.elapsed();
-
-    let content_ready_remaining = DASHBOARD_CONTENT_READY_BUDGET
-        .checked_sub(started.elapsed())
-        .unwrap_or_else(|| Duration::from_millis(0));
-    let content_ready =
-        panel.wait_for_dashboard_content_ready(&expected_content, content_ready_remaining)?;
-    assert_eq!(
-        content_ready.snapshot_for_expected(&expected_content),
-        expected_content.snapshot(),
-        "shell-enter dashboard content ready must match expected Ticket/action/overlay/header snapshot; artifacts at {}",
-        panel.artifacts().dir.display()
-    );
-    let content_ready_elapsed = started.elapsed();
-    eprintln!(
-        "panel shell-enter dashboard content ready: {content_ready_elapsed:?} (budget {DASHBOARD_CONTENT_READY_BUDGET:?}; first frame {first_visible_elapsed:?}); artifacts at {}",
-        panel.artifacts().dir.display()
-    );
+    panel.wait_for_first_visible_frame(FIRST_VISIBLE_RENDER_BUDGET)?;
+    panel.wait_for(
+        "shell-enter Backend dashboard content",
+        DASHBOARD_CONTENT_READY_BUDGET,
+        |event| {
+            event.event == "backend_dashboard_content_ready"
+                && has_backend_ticket(
+                    &event.data,
+                    &ready_ticket_id,
+                    "Planning E2E Ticket A",
+                    "planning",
+                )
+        },
+    )?;
     assert!(
-        content_ready_elapsed <= DASHBOARD_CONTENT_READY_BUDGET,
-        "shell-enter dashboard content ready took {content_ready_elapsed:?}, budget {DASHBOARD_CONTENT_READY_BUDGET:?}; artifacts at {}",
+        started.elapsed() <= DASHBOARD_CONTENT_READY_BUDGET,
+        "shell-enter Backend dashboard content missed startup budget; artifacts at {}",
         panel.artifacts().dir.display()
     );
 
-    let source_breakdown = panel.expect_dashboard_source_breakdown()?;
-    assert!(
-        source_breakdown.has_source("workspace_panel.build.total"),
-        "shell-enter dashboard source breakdown should include total panel build source; got {:?}; artifacts at {}",
-        source_breakdown,
-        panel.artifacts().dir.display()
-    );
-
-    panel.press(KeyPress::CtrlC)?;
+    panel.press(KeyPress::Esc)?;
     let status = panel.expect_exit_within(PanelHarness::default_exit_wait())?;
-    assert!(status.success(), "panel should exit cleanly with Ctrl+C");
+    assert!(
+        status.success(),
+        "Backend panel should exit cleanly with Escape"
+    );
     drop(panel);
-    assert_fixture_cleanup(fixture.cleanup()?);
+    let report = fixture.cleanup()?;
+    assert_fixture_cleanup(&report);
     Ok(())
 }
 
-#[test]
-fn panel_mouse_click_selects_row_without_dispatching_action() -> yoi_e2e::Result<()> {
-    let binary = yoi_binary()?;
-    let fixture = FixtureWorkspace::new(&binary)?;
-    assert_fixture_paths_are_isolated(&fixture);
-    let mut panel = PanelHarness::spawn(fixture.panel_config(binary))?;
-
-    panel.expect_mouse_capture_enabled()?;
-    panel.assert_no_full_drag_mouse_capture()?;
-    let rows = panel.wait_for_rows(2)?;
-    assert_no_runtime_or_host_pod_leak(
-        &fixture,
-        &rows.rows,
-        panel.artifacts().dir.display().to_string().as_str(),
-    );
-    let selected = rows.selected.clone();
-    let target = rows
-        .rows
-        .iter()
-        .find(|row| Some(&row.key) != selected.as_ref())
-        .cloned()
-        .expect("fixture should render a second selectable row");
-
-    let before_events = panel.events()?.len();
-    panel.click(&target)?;
-    panel.expect_selection(&target.key)?;
-
-    let events = panel.events()?;
-    assert!(
-        events[before_events..]
-            .iter()
-            .all(|event| event.event != "action_requested"),
-        "mouse selection must not dispatch panel actions; artifacts at {}",
-        panel.artifacts().dir.display()
-    );
-    panel.assert_no_full_drag_mouse_capture()?;
-
-    panel.press(KeyPress::CtrlC)?;
-    let status = panel.expect_exit_within(PanelHarness::default_exit_wait())?;
-    assert!(status.success(), "panel should exit cleanly with Ctrl+C");
-    drop(panel);
-    assert_fixture_cleanup(fixture.cleanup()?);
-    Ok(())
+fn has_backend_ticket(data: &Value, id: &str, title: &str, workflow_state: &str) -> bool {
+    data.get("tickets")
+        .and_then(Value::as_array)
+        .is_some_and(|tickets| {
+            tickets.iter().any(|ticket| {
+                ticket.get("id").and_then(Value::as_str) == Some(id)
+                    && ticket.get("title").and_then(Value::as_str) == Some(title)
+                    && ticket.get("workflow_state").and_then(Value::as_str) == Some(workflow_state)
+            })
+        })
 }
 
-#[test]
-fn panel_mouse_wheel_moves_selection_without_full_drag_capture() -> yoi_e2e::Result<()> {
-    let binary = yoi_binary()?;
-    let fixture = FixtureWorkspace::new(&binary)?;
-    assert_fixture_paths_are_isolated(&fixture);
-    let mut panel = PanelHarness::spawn(fixture.panel_config(binary))?;
-
-    panel.expect_mouse_capture_enabled()?;
-    panel.assert_no_full_drag_mouse_capture()?;
-    let rows = panel.wait_for_rows(2)?;
-    assert_no_runtime_or_host_pod_leak(
-        &fixture,
-        &rows.rows,
-        panel.artifacts().dir.display().to_string().as_str(),
-    );
-    let selected = rows
-        .selected
-        .as_ref()
-        .expect("fixture should render an initially selected row")
-        .clone();
-    let selected_index = rows
-        .rows
-        .iter()
-        .position(|row| row.key == selected)
-        .expect("selected row should be rendered");
-    let target_index = (selected_index + 1).min(rows.rows.len() - 1);
-    assert_ne!(
-        selected_index, target_index,
-        "fixture should render a wheel-selectable next row"
-    );
-    let source = rows.rows[selected_index].clone();
-    let target = rows.rows[target_index].clone();
-
-    let before_events = panel.events()?.len();
-    panel.wheel_down(&source)?;
-    panel.expect_selection(&target.key)?;
-    panel.assert_no_full_drag_mouse_capture()?;
-
-    let events = panel.events()?;
-    assert!(
-        events[before_events..]
-            .iter()
-            .any(|event| event.event == "mouse_wheel"),
-        "wheel movement should be visible in e2e events; artifacts at {}",
-        panel.artifacts().dir.display()
-    );
-    assert!(
-        events[before_events..]
-            .iter()
-            .all(|event| event.event != "action_requested"),
-        "wheel selection must not dispatch panel actions; artifacts at {}",
-        panel.artifacts().dir.display()
-    );
-
-    panel.press(KeyPress::CtrlC)?;
-    let status = panel.expect_exit_within(PanelHarness::default_exit_wait())?;
-    assert!(status.success(), "panel should exit cleanly with Ctrl+C");
-    drop(panel);
-    assert_fixture_cleanup(fixture.cleanup()?);
-    Ok(())
-}
-
-#[test]
-fn panel_ctrl_c_exits_promptly_after_background_barrier() -> yoi_e2e::Result<()> {
-    let binary = yoi_binary()?;
-    let fixture = FixtureWorkspace::new(&binary)?;
-    assert_fixture_paths_are_isolated(&fixture);
-    let mut panel =
-        PanelHarness::spawn(fixture.panel_config_holding_background_task(binary, "reload"))?;
-
-    panel.wait_for("panel_ready", Duration::from_secs(5), |event| {
-        event.event == "panel_ready"
-    })?;
-    panel.expect_background_task_pending("reload")?;
-
-    let started = std::time::Instant::now();
-    panel.press(KeyPress::CtrlC)?;
-    let status = panel.expect_exit_within(PanelHarness::default_exit_wait())?;
-    let elapsed = started.elapsed();
-
-    assert!(status.success(), "panel should exit cleanly with Ctrl+C");
-    assert!(
-        elapsed <= PanelHarness::default_exit_wait(),
-        "quit latency {elapsed:?} exceeded threshold; artifacts at {}",
-        panel.artifacts().dir.display()
-    );
-    let events = panel.events()?;
-    assert!(
-        events.iter().any(|event| event.event == "quit_requested"),
-        "quit_requested observability event missing; artifacts at {}",
-        panel.artifacts().dir.display()
-    );
-    assert!(
-        events.iter().any(|event| {
-            event.event == "background_task_aborted"
-                && event.data.get("task").and_then(serde_json::Value::as_str) == Some("reload")
-        }),
-        "pending reload task should be aborted before quit completes; artifacts at {}",
-        panel.artifacts().dir.display()
-    );
-    drop(panel);
-    assert_fixture_cleanup(fixture.cleanup()?);
-    Ok(())
-}
-
-fn assert_fixture_paths_are_isolated(fixture: &FixtureWorkspace) {
-    assert!(
-        fixture.root.exists(),
-        "fixture temp root should exist during scenario"
-    );
+fn assert_backend_fixture_is_isolated(fixture: &FixtureWorkspace) {
+    assert!(fixture.root.exists());
     assert!(fixture.workspace.starts_with(&fixture.root));
     assert!(fixture.home.starts_with(&fixture.root));
     assert!(fixture.xdg_data_home.starts_with(&fixture.root));
     assert!(fixture.xdg_state_home.starts_with(&fixture.root));
     assert!(fixture.xdg_config_home.starts_with(&fixture.root));
     assert!(fixture.xdg_runtime_dir.starts_with(&fixture.root));
-    assert!(
-        !fixture.artifacts_dir.starts_with(&fixture.root),
-        "persistent artifacts must live outside the temp root so cleanup can remove the fixture"
-    );
-    if let Some(host_runtime) = std::env::var_os("XDG_RUNTIME_DIR") {
-        assert_ne!(
-            fixture.xdg_runtime_dir,
-            std::path::PathBuf::from(host_runtime),
-            "tested yoi must not reuse host XDG_RUNTIME_DIR"
-        );
-    }
+    assert!(!fixture.workspace.join(".yoi").exists());
+    assert!(fixture.backend_target().is_some());
 }
 
-fn assert_no_runtime_or_host_pod_leak(
-    fixture: &FixtureWorkspace,
-    rows: &[RenderedPanelRow],
-    artifacts: &str,
-) {
-    let rendered = rows
-        .iter()
-        .map(|row| {
-            format!(
-                "{} {} {} {}",
-                row.key.kind,
-                row.key.id,
-                row.title,
-                row.status.as_deref().unwrap_or_default()
-            )
-        })
-        .collect::<Vec<_>>()
-        .join("\n");
-    for marker in [
-        "workspace-orchestrator",
-        "yoi-orchestrator-orchestrator",
-        "host-runtime-leak",
-    ] {
-        assert!(
-            !rendered.contains(marker),
-            "host/fixture runtime Worker marker {marker:?} leaked into panel rows; artifacts at {artifacts}\n{rendered}"
-        );
-    }
-    if let Some(host_runtime) = std::env::var_os("XDG_RUNTIME_DIR") {
-        let host_runtime = host_runtime.to_string_lossy();
-        assert!(
-            !rendered.contains(host_runtime.as_ref()),
-            "host XDG_RUNTIME_DIR leaked into panel rows; artifacts at {artifacts}\n{rendered}"
-        );
-    }
-    assert!(
-        rendered.contains("E2E Ticket"),
-        "panel should be observing fixture-local Ticket data; artifacts at {artifacts}\n{rendered}"
-    );
-    assert!(fixture.xdg_runtime_dir.starts_with(&fixture.root));
-}
-
-fn assert_fixture_cleanup(report: FixtureCleanupReport) {
+fn assert_fixture_cleanup(report: &FixtureCleanupReport) {
     assert!(
         report.cleanup_success,
         "fixture cleanup failed; report at {}: {:?}",
         report.report_path.display(),
         report.cleanup_error
     );
-    assert!(
-        !report.fixture_root.exists(),
-        "fixture temp root should be removed after scenario: {}",
-        report.fixture_root.display()
-    );
-    assert!(
-        report.report_path.exists(),
-        "cleanup artifact should persist"
-    );
-    assert!(
-        report.snapshot_dir.exists(),
-        "fixture snapshot should persist under target/e2e-artifacts before temp cleanup"
-    );
+    assert!(!report.fixture_root.exists());
+    assert!(report.report_path.exists());
+    assert!(report.snapshot_dir.exists());
+    let snapshot = fs::read_to_string(report.snapshot_dir.join("../fixture.json")).unwrap();
+    assert!(!snapshot.contains("yoi_api_"));
 }