diff --git a/Cargo.lock b/Cargo.lock
index 56ddce02f..e3312abd1 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -381,9 +381,9 @@ dependencies = [
 
 [[package]]
 name = "aws-credential-types"
-version = "1.2.5"
+version = "1.2.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1541072f81945fa1251f8795ef6c92c4282d74d59f88498ae7d4bf00f0ebdad9"
+checksum = "799a1290207254984cb7c05245111bc77958b92a3c9bb449598044b36341cce6"
 dependencies = [
  "aws-smithy-async",
  "aws-smithy-runtime-api",
@@ -425,13 +425,14 @@ dependencies = [
 
 [[package]]
 name = "aws-runtime"
-version = "1.5.10"
+version = "1.5.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c034a1bc1d70e16e7f4e4caf7e9f7693e4c9c24cd91cf17c2a0b21abaebc7c8b"
+checksum = "2e1ed337dabcf765ad5f2fb426f13af22d576328aaf09eac8f70953530798ec0"
 dependencies = [
  "aws-credential-types",
  "aws-sigv4",
  "aws-smithy-async",
+ "aws-smithy-eventstream",
  "aws-smithy-http 0.62.3",
  "aws-smithy-runtime",
  "aws-smithy-runtime-api",
@@ -447,6 +448,31 @@ dependencies = [
  "uuid",
 ]
 
+[[package]]
+name = "aws-sdk-bedrockruntime"
+version = "1.108.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed130f6272d73c74add30ee17835c475c89271786b0c70e81342556ed15e3d4e"
+dependencies = [
+ "aws-credential-types",
+ "aws-runtime",
+ "aws-sigv4",
+ "aws-smithy-async",
+ "aws-smithy-eventstream",
+ "aws-smithy-http 0.62.3",
+ "aws-smithy-json",
+ "aws-smithy-runtime",
+ "aws-smithy-runtime-api",
+ "aws-smithy-types",
+ "aws-types",
+ "bytes",
+ "fastrand",
+ "http 0.2.12",
+ "hyper 0.14.32",
+ "regex-lite",
+ "tracing",
+]
+
 [[package]]
 name = "aws-sdk-cognitoidentity"
 version = "1.80.0"
@@ -543,6 +569,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "084c34162187d39e3740cb635acd73c4e3a551a36146ad6fe8883c929c9f876c"
 dependencies = [
  "aws-credential-types",
+ "aws-smithy-eventstream",
  "aws-smithy-http 0.62.3",
  "aws-smithy-runtime-api",
  "aws-smithy-types",
@@ -571,9 +598,9 @@ dependencies = [
 
 [[package]]
 name = "aws-smithy-eventstream"
-version = "0.60.10"
+version = "0.60.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "604c7aec361252b8f1c871a7641d5e0ba3a7f5a586e51b66bc9510a5519594d9"
+checksum = "182b03393e8c677347fb5705a04a9392695d47d20ef0a2f8cfe28c8e6b9b9778"
 dependencies = [
  "aws-smithy-types",
  "bytes",
@@ -607,6 +634,7 @@ version = "0.62.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7c4dacf2d38996cf729f55e7a762b30918229917eca115de45dfa8dfb97796c9"
 dependencies = [
+ "aws-smithy-eventstream",
  "aws-smithy-runtime-api",
  "aws-smithy-types",
  "bytes",
@@ -623,9 +651,9 @@ dependencies = [
 
 [[package]]
 name = "aws-smithy-http-client"
-version = "1.0.6"
+version = "1.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f108f1ca850f3feef3009bdcc977be201bca9a91058864d9de0684e64514bee0"
+checksum = "734b4282fbb7372923ac339cc2222530f8180d9d4745e582de19a18cee409fd8"
 dependencies = [
  "aws-smithy-async",
  "aws-smithy-protocol-test",
@@ -652,15 +680,16 @@ dependencies = [
  "serde",
  "serde_json",
  "tokio",
- "tower",
+ "tokio-rustls 0.26.2",
+ "tower 0.5.2",
  "tracing",
 ]
 
 [[package]]
 name = "aws-smithy-json"
-version = "0.61.4"
+version = "0.61.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a16e040799d29c17412943bdbf488fd75db04112d0c0d4b9290bacf5ae0014b9"
+checksum = "eaa31b350998e703e9826b2104dd6f63be0508666e1aba88137af060e8944047"
 dependencies = [
  "aws-smithy-types",
 ]
@@ -705,9 +734,9 @@ dependencies = [
 
 [[package]]
 name = "aws-smithy-runtime"
-version = "1.8.6"
+version = "1.9.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e107ce0783019dbff59b3a244aa0c114e4a8c9d93498af9162608cd5474e796"
+checksum = "4fa63ad37685ceb7762fa4d73d06f1d5493feb88e3f27259b9ed277f4c01b185"
 dependencies = [
  "aws-smithy-async",
  "aws-smithy-http 0.62.3",
@@ -730,9 +759,9 @@ dependencies = [
 
 [[package]]
 name = "aws-smithy-runtime-api"
-version = "1.8.7"
+version = "1.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "75d52251ed4b9776a3e8487b2a01ac915f73b2da3af8fc1e77e0fce697a550d4"
+checksum = "07f5e0fc8a6b3f2303f331b94504bbf754d85488f402d6f1dd7a6080f99afe56"
 dependencies = [
  "aws-smithy-async",
  "aws-smithy-types",
@@ -807,6 +836,64 @@ dependencies = [
  "tracing",
 ]
 
+[[package]]
+name = "axum"
+version = "0.7.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "edca88bc138befd0323b20752846e6587272d3b03b0343c8ea28a6f819e6e71f"
+dependencies = [
+ "async-trait",
+ "axum-core",
+ "base64 0.22.1",
+ "bytes",
+ "futures-util",
+ "http 1.3.1",
+ "http-body 1.0.1",
+ "http-body-util",
+ "hyper 1.6.0",
+ "hyper-util",
+ "itoa",
+ "matchit",
+ "memchr",
+ "mime",
+ "percent-encoding",
+ "pin-project-lite",
+ "rustversion",
+ "serde",
+ "serde_json",
+ "serde_path_to_error",
+ "serde_urlencoded",
+ "sha1",
+ "sync_wrapper",
+ "tokio",
+ "tokio-tungstenite 0.24.0",
+ "tower 0.5.2",
+ "tower-layer",
+ "tower-service",
+ "tracing",
+]
+
+[[package]]
+name = "axum-core"
+version = "0.4.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09f2bd6146b97ae3359fa0cc6d6b376d9539582c7b4220f041a33ec24c226199"
+dependencies = [
+ "async-trait",
+ "bytes",
+ "futures-util",
+ "http 1.3.1",
+ "http-body 1.0.1",
+ "http-body-util",
+ "mime",
+ "pin-project-lite",
+ "rustversion",
+ "sync_wrapper",
+ "tower-layer",
+ "tower-service",
+ "tracing",
+]
+
 [[package]]
 name = "backtrace"
 version = "0.3.75"
@@ -1317,12 +1404,14 @@ dependencies = [
  "aws-config",
  "aws-credential-types",
  "aws-runtime",
+ "aws-sdk-bedrockruntime",
  "aws-sdk-cognitoidentity",
  "aws-sdk-ssooidc",
  "aws-smithy-async",
  "aws-smithy-runtime-api",
  "aws-smithy-types",
  "aws-types",
+ "axum",
  "base64 0.22.1",
  "bitflags 2.9.1",
  "bstr",
@@ -1406,9 +1495,11 @@ dependencies = [
  "thiserror 2.0.14",
  "time",
  "tokio",
- "tokio-tungstenite",
+ "tokio-tungstenite 0.26.2",
  "tokio-util",
  "toml",
+ "tower 0.4.13",
+ "tower-http 0.5.2",
  "tracing",
  "tracing-appender",
  "tracing-subscriber",
@@ -3187,6 +3278,12 @@ dependencies = [
  "pin-project-lite",
 ]
 
+[[package]]
+name = "http-range-header"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9171a2ea8a68358193d15dd5d70c1c10a2afc3e7e4c5bc92bc9f025cebd7359c"
+
 [[package]]
 name = "httparse"
 version = "1.10.1"
@@ -3935,6 +4032,12 @@ dependencies = [
  "regex-automata",
 ]
 
+[[package]]
+name = "matchit"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0e7465ac9959cc2b1404e8e2367b43684a6d13790fe23056cc8c6c5a6b7bcb94"
+
 [[package]]
 name = "md-5"
 version = "0.10.6"
@@ -4013,6 +4116,16 @@ version = "0.3.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a"
 
+[[package]]
+name = "mime_guess"
+version = "2.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f7c44f8e672c00fe5308fa235f821cb4198414e1c77935c1ab6948d3fd78550e"
+dependencies = [
+ "mime",
+ "unicase",
+]
+
 [[package]]
 name = "minimal-lexical"
 version = "0.2.1"
@@ -5564,8 +5677,8 @@ dependencies = [
  "tokio",
  "tokio-rustls 0.26.2",
  "tokio-util",
- "tower",
- "tower-http",
+ "tower 0.5.2",
+ "tower-http 0.6.6",
  "tower-service",
  "url",
  "wasm-bindgen",
@@ -6865,6 +6978,18 @@ dependencies = [
  "tokio",
 ]
 
+[[package]]
+name = "tokio-tungstenite"
+version = "0.24.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "edc5f74e248dc973e0dbb7b74c7e0d6fcc301c694ff50049504004ef4d0cdcd9"
+dependencies = [
+ "futures-util",
+ "log",
+ "tokio",
+ "tungstenite 0.24.0",
+]
+
 [[package]]
 name = "tokio-tungstenite"
 version = "0.26.2"
@@ -6874,7 +6999,7 @@ dependencies = [
  "futures-util",
  "log",
  "tokio",
- "tungstenite",
+ "tungstenite 0.26.2",
 ]
 
 [[package]]
@@ -6932,6 +7057,17 @@ version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5d99f8c9a7727884afe522e9bd5edbfc91a3312b36a77b5fb8926e4c31a41801"
 
+[[package]]
+name = "tower"
+version = "0.4.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8fa9be0de6cf49e536ce1851f987bd21a43b771b09473c3549a6c853db37c1c"
+dependencies = [
+ "tower-layer",
+ "tower-service",
+ "tracing",
+]
+
 [[package]]
 name = "tower"
 version = "0.5.2"
@@ -6945,6 +7081,32 @@ dependencies = [
  "tokio",
  "tower-layer",
  "tower-service",
+ "tracing",
+]
+
+[[package]]
+name = "tower-http"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e9cd434a998747dd2c4276bc96ee2e0c7a2eadf3cae88e52be55a05fa9053f5"
+dependencies = [
+ "bitflags 2.9.1",
+ "bytes",
+ "futures-util",
+ "http 1.3.1",
+ "http-body 1.0.1",
+ "http-body-util",
+ "http-range-header",
+ "httpdate",
+ "mime",
+ "mime_guess",
+ "percent-encoding",
+ "pin-project-lite",
+ "tokio",
+ "tokio-util",
+ "tower-layer",
+ "tower-service",
+ "tracing",
 ]
 
 [[package]]
@@ -6960,7 +7122,7 @@ dependencies = [
  "http-body 1.0.1",
  "iri-string",
  "pin-project-lite",
- "tower",
+ "tower 0.5.2",
  "tower-layer",
  "tower-service",
 ]
@@ -7135,6 +7297,24 @@ dependencies = [
  "unicode-width 0.1.14",
 ]
 
+[[package]]
+name = "tungstenite"
+version = "0.24.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "18e5b8366ee7a95b16d32197d0b2604b43a0be89dc5fac9f8e96ccafbaedda8a"
+dependencies = [
+ "byteorder",
+ "bytes",
+ "data-encoding",
+ "http 1.3.1",
+ "httparse",
+ "log",
+ "rand 0.8.5",
+ "sha1",
+ "thiserror 1.0.69",
+ "utf-8",
+]
+
 [[package]]
 name = "tungstenite"
 version = "0.26.2"
diff --git a/Cargo.toml b/Cargo.toml
index 5add67b3c..787b5b519 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,7 @@
 [workspace]
 resolver = "3"
 members = ["crates/amzn-codewhisperer-client", "crates/amzn-codewhisperer-streaming-client", "crates/amzn-consolas-client", "crates/amzn-qdeveloper-streaming-client", "crates/amzn-toolkit-telemetry-client", "crates/aws-toolkit-telemetry-definitions", "crates/chat-cli", "crates/semantic-search-client", "crates/chat-cli-ui"]
+exclude = ["crates/chat-exp"]
 default-members = ["crates/chat-cli"]
 
 [workspace.package]
diff --git a/crates/chat-cli/Cargo.toml b/crates/chat-cli/Cargo.toml
index 26524e0b1..b78cada10 100644
--- a/crates/chat-cli/Cargo.toml
+++ b/crates/chat-cli/Cargo.toml
@@ -27,6 +27,7 @@ async-trait.workspace = true
 aws-config.workspace = true
 aws-credential-types.workspace = true
 aws-runtime.workspace = true
+aws-sdk-bedrockruntime = "1.106.0"
 aws-sdk-cognitoidentity.workspace = true
 aws-sdk-ssooidc.workspace = true
 aws-smithy-async.workspace = true
@@ -103,6 +104,9 @@ time.workspace = true
 tokio.workspace = true
 tokio-tungstenite.workspace = true
 tokio-util.workspace = true
+axum = { version = "0.7", features = ["ws"] }
+tower = "0.4"
+tower-http = { version = "0.5", features = ["fs", "cors"] }
 toml.workspace = true
 tracing.workspace = true
 tracing-appender.workspace = true
diff --git a/crates/chat-cli/src/agent_env/agent_environment.rs b/crates/chat-cli/src/agent_env/agent_environment.rs
new file mode 100644
index 000000000..b9cc146c6
--- /dev/null
+++ b/crates/chat-cli/src/agent_env/agent_environment.rs
@@ -0,0 +1,526 @@
+//! AgentEnvironment Coordinator
+//!
+//! Top-level coordinator that manages event multicasting, UI coordination, and command processing.
+//! Supports multiple concurrent UIs (one main interactive UI + multiple headless UIs).
+
+use async_trait::async_trait;
+use eyre::Result;
+use std::sync::Arc;
+use tokio::sync::{mpsc, Notify};
+use tokio::task::JoinHandle;
+
+use super::{
+    commands::{AgentEnvironmentCommand, PromptResult},
+    event_bus::EventBus,
+    events::AgentEnvironmentEvent,
+    session::Session,
+};
+
+/// Main interactive UI interface
+#[async_trait]
+pub trait UserInterface: Send + Sync {
+    /// Start UI (spawns tasks, returns immediately)
+    async fn start(&self) -> Result<()>;
+
+    /// Get receiver for commands from this UI
+    fn command_receiver(&self) -> mpsc::Receiver<PromptResult>;
+
+    /// Handle event from EventBus (called by AgentEnvironment)
+    async fn handle_event(&self, event: AgentEnvironmentEvent);
+}
+
+/// Headless UI interface (non-interactive)
+#[async_trait]
+pub trait HeadlessInterface: Send + Sync {
+    /// Handle event from EventBus
+    async fn handle_event(&self, event: AgentEnvironmentEvent);
+}
+
+/// AgentEnvironment coordinator
+///
+/// Manages event multicasting, UI coordination, and command processing.
+/// Supports one main interactive UI and multiple headless UIs.
+pub struct AgentEnvironment {
+    session: Arc<Session>,
+    event_bus: EventBus,
+    main_ui: Option<Arc<dyn UserInterface>>,
+    headless_uis: Vec<Arc<dyn HeadlessInterface>>,
+    shutdown_signal: Arc<Notify>,
+    interactive: bool,
+}
+
+impl AgentEnvironment {
+    /// Create new AgentEnvironment
+    pub fn new(
+        session: Arc<Session>,
+        event_bus: EventBus,
+        main_ui: Option<Arc<dyn UserInterface>>,
+        headless_uis: Vec<Arc<dyn HeadlessInterface>>,
+        interactive: bool,
+    ) -> Self {
+        Self {
+            session,
+            event_bus,
+            main_ui,
+            headless_uis,
+            shutdown_signal: Arc::new(Notify::new()),
+            interactive,
+        }
+    }
+
+    /// Spawn event multicast task
+    fn spawn_event_multicast(&self) -> JoinHandle<()> {
+        let mut receiver = self.event_bus.subscribe();
+        let headless_uis = self.headless_uis.clone();
+        let main_ui = self.main_ui.clone();
+        let shutdown = self.shutdown_signal.clone();
+
+        tokio::spawn(async move {
+            loop {
+                tokio::select! {
+                    result = receiver.recv() => {
+                        match result {
+                            Ok(event) => {
+                                // Forward to main UI
+                                if let Some(ui) = &main_ui {
+                                    ui.handle_event(event.clone()).await;
+                                }
+
+                                // Forward to headless UIs
+                                for headless_ui in &headless_uis {
+                                    headless_ui.handle_event(event.clone()).await;
+                                }
+                            }
+                            Err(tokio::sync::broadcast::error::RecvError::Lagged(n)) => {
+                                tracing::warn!("Event bus lagged by {} events", n);
+                            }
+                            Err(tokio::sync::broadcast::error::RecvError::Closed) => {
+                                tracing::info!("Event bus closed");
+                                break;
+                            }
+                        }
+                    }
+                    _ = shutdown.notified() => {
+                        tracing::info!("Event multicast shutting down");
+                        break;
+                    }
+                }
+            }
+        })
+    }
+
+    /// Start event multicasting (call before creating workers to capture all events)
+    pub fn start_event_multicasting(&self) {
+        self.spawn_event_multicast();
+    }
+
+    /// Spawn job completion monitor for non-interactive mode
+    /// 
+    /// Monitors JobEvent::Completed events and triggers shutdown when all jobs complete.
+    /// Only active in non-interactive mode (interactive=false).
+    pub fn spawn_job_completion_monitor(&self) -> JoinHandle<()> {
+        // Early return if interactive mode
+        if self.interactive {
+            return tokio::spawn(async {});
+        }
+
+        let mut receiver = self.event_bus.subscribe();
+        let session = self.session.clone();
+        let shutdown = self.shutdown_signal.clone();
+
+        tokio::spawn(async move {
+            use super::events::{AgentEnvironmentEvent, JobEvent, JobCompletionResult, UserInteractionRequired};
+
+            loop {
+                match receiver.recv().await {
+                    Ok(AgentEnvironmentEvent::Job(JobEvent::Completed { result, .. })) => {
+                        // Check if there are any active jobs remaining
+                        if !session.has_active_jobs() {
+                            // Check completion status
+                            match &result {
+                                JobCompletionResult::Success { user_interaction_required, .. } => {
+                                    if *user_interaction_required == UserInteractionRequired::ToolApproval {
+                                        eprintln!("Warning: Job completed with pending tool approval (non-clean exit)");
+                                    }
+                                }
+                                JobCompletionResult::Failed { error } => {
+                                    eprintln!("Error: Job failed: {}", error);
+                                }
+                                JobCompletionResult::Cancelled => {
+                                    eprintln!("Warning: Job was cancelled");
+                                }
+                            }
+
+                            // Trigger shutdown
+                            shutdown.notify_waiters();
+                            break;
+                        }
+                    }
+                    Ok(_) => {
+                        // Ignore other events
+                    }
+                    Err(tokio::sync::broadcast::error::RecvError::Lagged(n)) => {
+                        tracing::warn!("Job completion monitor lagged by {} events", n);
+                    }
+                    Err(tokio::sync::broadcast::error::RecvError::Closed) => {
+                        tracing::info!("Event bus closed in job completion monitor");
+                        break;
+                    }
+                }
+            }
+        })
+    }
+
+    /// Handle command from UI
+    async fn handle_command(&self, cmd: AgentEnvironmentCommand) -> Result<()> {
+        match cmd {
+            AgentEnvironmentCommand::Prompt { worker_id, text } => {
+                let worker = self
+                    .session
+                    .get_worker(worker_id)
+                    .ok_or_else(|| eyre::eyre!("Worker not found: {}", worker_id))?;
+
+                // Add message to conversation history
+                worker
+                    .context_container
+                    .conversation_history
+                    .lock()
+                    .unwrap()
+                    .push_input_message(text);
+
+                // Launch agent loop
+                self.session
+                    .run_task__agent_loop(worker, crate::agent_env::worker_tasks::AgentLoopInput {})?;
+            }
+
+            AgentEnvironmentCommand::Compact {
+                worker_id,
+                instruction,
+            } => {
+                let worker = self
+                    .session
+                    .get_worker(worker_id)
+                    .ok_or_else(|| eyre::eyre!("Worker not found: {}", worker_id))?;
+
+                // Launch compact task (stub for Phase 10)
+                self.session.run_task__compact_conversation(
+                    worker,
+                    crate::agent_env::worker_tasks::CompactInput { instruction },
+                )?;
+            }
+
+            AgentEnvironmentCommand::Quit => {
+                self.shutdown_signal.notify_waiters();
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Trigger shutdown
+    pub fn shutdown(&self) {
+        self.shutdown_signal.notify_waiters();
+    }
+    
+    /// Get shutdown signal for external coordination
+    pub fn shutdown_signal(&self) -> Arc<Notify> {
+        self.shutdown_signal.clone()
+    }
+
+    /// Main execution loop
+    pub async fn run(&self) -> Result<()> {
+        // Start Ctrl+C handler
+        use crate::cli::chat::agent_env_ui::CtrlCHandler;
+        let ctrl_c_handler = Arc::new(CtrlCHandler::new(
+            self.shutdown_signal.clone(),
+            self.session.clone(),
+        ));
+        ctrl_c_handler.start_listening();
+        
+        // Note: Event multicast task should already be started via start_event_multicasting()
+        // before calling run(). If not started, start it now for backward compatibility.
+        // This is a no-op if already started since we're using broadcast channels.
+
+        // Run main UI if present
+        if let Some(ui) = &self.main_ui {
+            // Start UI (spawns its own tasks, returns immediately)
+            ui.start().await?;
+
+            // Get command receiver from UI
+            let mut cmd_receiver = ui.command_receiver();
+
+            // Main loop: process commands without blocking events
+            loop {
+                tokio::select! {
+                    // Process UI commands
+                    Some(result) = cmd_receiver.recv() => {
+                        match result {
+                            PromptResult::Command(cmd) => {
+                                // Check for Quit command before handling
+                                let is_quit = matches!(cmd, AgentEnvironmentCommand::Quit);
+                                
+                                if let Err(e) = self.handle_command(cmd).await {
+                                    tracing::error!("Error handling command: {}", e);
+                                }
+                                
+                                // Break immediately after Quit
+                                if is_quit {
+                                    tracing::info!("Quit command received");
+                                    break;
+                                }
+                            }
+                            PromptResult::Shutdown => {
+                                tracing::info!("Shutdown requested by UI");
+                                break;
+                            }
+                        }
+                    }
+
+                    // Handle shutdown signal
+                    _ = self.shutdown_signal.notified() => {
+                        tracing::info!("Shutdown signal received");
+                        break;
+                    }
+                }
+            }
+        } else {
+            // Headless mode - just wait for shutdown
+            tracing::info!("Running in headless mode");
+            self.shutdown_signal.notified().await;
+        }
+
+        // Cleanup
+        tracing::info!("Shutting down AgentEnvironment");
+        // Note: Event multicast task will shut down via shutdown_signal
+        self.session.cancel_all_jobs();
+        
+        tracing::info!("AgentEnvironment cleanup complete, returning");
+
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::sync::Mutex as StdMutex;
+    use tokio::sync::mpsc;
+    use uuid::Uuid;
+
+    // Mock UserInterface for testing
+    struct MockUserInterface {
+        events_received: Arc<StdMutex<Vec<AgentEnvironmentEvent>>>,
+        cmd_sender: mpsc::Sender<PromptResult>,
+        cmd_receiver: Arc<StdMutex<Option<mpsc::Receiver<PromptResult>>>>,
+    }
+
+    impl MockUserInterface {
+        fn new() -> (Self, mpsc::Receiver<PromptResult>) {
+            let (cmd_sender, cmd_receiver) = mpsc::channel(10);
+            let ui = Self {
+                events_received: Arc::new(StdMutex::new(Vec::new())),
+                cmd_sender,
+                cmd_receiver: Arc::new(StdMutex::new(Some(cmd_receiver))),
+            };
+            // Return a dummy receiver since we can't return the real one twice
+            let (_, dummy_receiver) = mpsc::channel(1);
+            (ui, dummy_receiver)
+        }
+
+        fn get_events(&self) -> Vec<AgentEnvironmentEvent> {
+            self.events_received.lock().unwrap().clone()
+        }
+    }
+
+    #[async_trait]
+    impl UserInterface for MockUserInterface {
+        async fn start(&self) -> Result<()> {
+            Ok(())
+        }
+
+        fn command_receiver(&self) -> mpsc::Receiver<PromptResult> {
+            self.cmd_receiver
+                .lock()
+                .unwrap()
+                .take()
+                .expect("command_receiver called more than once")
+        }
+
+        async fn handle_event(&self, event: AgentEnvironmentEvent) {
+            self.events_received.lock().unwrap().push(event);
+        }
+    }
+
+    // Mock HeadlessInterface for testing
+    struct MockHeadlessInterface {
+        events_received: Arc<StdMutex<Vec<AgentEnvironmentEvent>>>,
+    }
+
+    impl MockHeadlessInterface {
+        fn new() -> Self {
+            Self {
+                events_received: Arc::new(StdMutex::new(Vec::new())),
+            }
+        }
+
+        fn get_events(&self) -> Vec<AgentEnvironmentEvent> {
+            self.events_received.lock().unwrap().clone()
+        }
+    }
+
+    #[async_trait]
+    impl HeadlessInterface for MockHeadlessInterface {
+        async fn handle_event(&self, event: AgentEnvironmentEvent) {
+            self.events_received.lock().unwrap().push(event);
+        }
+    }
+
+    #[tokio::test]
+    async fn test_event_multicast_to_main_ui() {
+        let event_bus = EventBus::default();
+        let model_providers = vec![];
+        let session = Arc::new(Session::new(event_bus.clone(), model_providers));
+
+        let (mock_ui, _) = MockUserInterface::new();
+        let mock_ui = Arc::new(mock_ui);
+
+        let agent_env = AgentEnvironment::new(
+            session.clone(),
+            event_bus.clone(),
+            Some(mock_ui.clone()),
+            vec![],
+            true, // interactive mode for test
+        );
+
+        // Spawn multicast task
+        let _handle = agent_env.spawn_event_multicast();
+
+        // Give multicast task time to start
+        tokio::time::sleep(tokio::time::Duration::from_millis(10)).await;
+
+        // Publish test event
+        let test_event = AgentEnvironmentEvent::System(
+            crate::agent_env::events::SystemEvent::ShutdownInitiated {
+                reason: "test".to_string(),
+                timestamp: std::time::Instant::now(),
+            },
+        );
+        event_bus.publish(test_event.clone());
+
+        // Give time for event to be processed
+        tokio::time::sleep(tokio::time::Duration::from_millis(50)).await;
+
+        // Verify mock UI received the event
+        let events = mock_ui.get_events();
+        assert_eq!(events.len(), 1);
+        assert!(events[0].is_system_event());
+    }
+
+    #[tokio::test]
+    async fn test_event_multicast_to_headless_uis() {
+        let event_bus = EventBus::default();
+        let model_providers = vec![];
+        let session = Arc::new(Session::new(event_bus.clone(), model_providers));
+
+        let headless1 = Arc::new(MockHeadlessInterface::new());
+        let headless2 = Arc::new(MockHeadlessInterface::new());
+
+        let agent_env = AgentEnvironment::new(
+            session.clone(),
+            event_bus.clone(),
+            None,
+            vec![headless1.clone(), headless2.clone()],
+            true, // interactive mode for test
+        );
+
+        // Spawn multicast task
+        let _handle = agent_env.spawn_event_multicast();
+
+        // Give multicast task time to start
+        tokio::time::sleep(tokio::time::Duration::from_millis(10)).await;
+
+        // Publish test event
+        let test_event = AgentEnvironmentEvent::System(
+            crate::agent_env::events::SystemEvent::ShutdownInitiated {
+                reason: "test".to_string(),
+                timestamp: std::time::Instant::now(),
+            },
+        );
+        event_bus.publish(test_event.clone());
+
+        // Give time for event to be processed
+        tokio::time::sleep(tokio::time::Duration::from_millis(50)).await;
+
+        // Verify both headless UIs received the event
+        let events1 = headless1.get_events();
+        let events2 = headless2.get_events();
+        assert_eq!(events1.len(), 1);
+        assert_eq!(events2.len(), 1);
+        assert!(events1[0].is_system_event());
+        assert!(events2[0].is_system_event());
+    }
+
+    #[tokio::test]
+    async fn test_shutdown_coordination() {
+        let event_bus = EventBus::default();
+        let model_providers = vec![];
+        let session = Arc::new(Session::new(event_bus.clone(), model_providers));
+
+        let agent_env = AgentEnvironment::new(session.clone(), event_bus.clone(), None, vec![], true);
+
+        // Spawn run() in background
+        let agent_env_clone = Arc::new(agent_env);
+        let run_handle = {
+            let agent_env = agent_env_clone.clone();
+            tokio::spawn(async move { agent_env.run().await })
+        };
+
+        // Give run() time to start
+        tokio::time::sleep(tokio::time::Duration::from_millis(10)).await;
+
+        // Trigger shutdown
+        agent_env_clone.shutdown();
+
+        // Wait for run() to complete with timeout
+        let result = tokio::time::timeout(
+            tokio::time::Duration::from_secs(1),
+            run_handle,
+        )
+        .await;
+
+        assert!(result.is_ok(), "run() should complete after shutdown");
+        assert!(result.unwrap().is_ok(), "run() should not error");
+    }
+
+    #[tokio::test]
+    async fn test_headless_mode() {
+        let event_bus = EventBus::default();
+        let model_providers = vec![];
+        let session = Arc::new(Session::new(event_bus.clone(), model_providers));
+
+        let agent_env = AgentEnvironment::new(session.clone(), event_bus.clone(), None, vec![], true);
+
+        // Spawn run() in background
+        let agent_env = Arc::new(agent_env);
+        let agent_env_clone = agent_env.clone();
+        let run_handle = tokio::spawn(async move { agent_env_clone.run().await });
+
+        // Give run() time to start
+        tokio::time::sleep(tokio::time::Duration::from_millis(10)).await;
+
+        // Verify it's running (doesn't exit immediately)
+        assert!(!run_handle.is_finished());
+
+        // Trigger shutdown
+        agent_env.shutdown();
+
+        // Wait for completion
+        let result = tokio::time::timeout(
+            tokio::time::Duration::from_secs(1),
+            run_handle,
+        )
+        .await;
+
+        assert!(result.is_ok(), "headless mode should exit cleanly");
+    }
+}
diff --git a/crates/chat-cli/src/agent_env/commands.rs b/crates/chat-cli/src/agent_env/commands.rs
new file mode 100644
index 000000000..d9191b281
--- /dev/null
+++ b/crates/chat-cli/src/agent_env/commands.rs
@@ -0,0 +1,207 @@
+//! Command system for AgentEnvironment
+//!
+//! This module defines the command types used for communication between UIs and AgentEnvironment.
+//! Commands are parsed from user input and routed to appropriate handlers.
+
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+
+/// Commands that AgentEnvironment handles (task-spawning operations)
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub enum AgentEnvironmentCommand {
+    /// Send a prompt to a worker
+    Prompt { worker_id: Uuid, text: String },
+    /// Compact conversation history for a worker
+    Compact {
+        worker_id: Uuid,
+        instruction: Option<String>,
+    },
+    /// Quit the application
+    Quit,
+}
+
+/// Commands that UI handles internally (display-only operations)
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub enum UiCommand {
+    /// Display token usage statistics
+    Usage,
+    /// Display context information
+    Context,
+    /// Display worker status
+    Status,
+    /// List all workers
+    Workers,
+    // UI-specific commands can be added by implementations
+}
+
+/// Parsed command from user input
+#[derive(Debug, Clone)]
+pub enum Command {
+    /// Forward to AgentEnvironment for execution
+    Agent(AgentEnvironmentCommand),
+    /// Handle in UI
+    Ui(UiCommand),
+}
+
+/// Result from UI prompt
+#[derive(Debug, Clone)]
+pub enum PromptResult {
+    /// Pass command to AgentEnvironment
+    Command(AgentEnvironmentCommand),
+    /// Shutdown requested
+    Shutdown,
+}
+
+/// Error type for command parsing
+#[derive(Debug, Clone)]
+pub enum ParseError {
+    /// Unknown command name
+    UnknownCommand(String),
+}
+
+impl std::fmt::Display for ParseError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            ParseError::UnknownCommand(cmd) => write!(f, "Unknown command: {}", cmd),
+        }
+    }
+}
+
+impl std::error::Error for ParseError {}
+
+/// Command parser for user input
+pub struct CommandParser;
+
+impl CommandParser {
+    /// Parse user input into a Command
+    ///
+    /// # Examples
+    ///
+    /// ```ignore
+    /// // Explicit commands
+    /// let cmd = CommandParser::parse("/quit")?;
+    /// let cmd = CommandParser::parse("/compact summarize briefly")?;
+    /// let cmd = CommandParser::parse("/usage")?;
+    ///
+    /// // Implicit prompt command
+    /// let cmd = CommandParser::parse("Hello, world!")?;
+    /// ```
+    pub fn parse(input: &str) -> Result<Command, ParseError> {
+        let trimmed = input.trim();
+
+        if trimmed.starts_with('/') {
+            // Explicit command
+            let parts: Vec<&str> = trimmed[1..].splitn(2, ' ').collect();
+            match parts[0] {
+                "quit" | "q" => Ok(Command::Agent(AgentEnvironmentCommand::Quit)),
+                "compact" => {
+                    let instruction = parts.get(1).map(|s| s.to_string());
+                    Ok(Command::Agent(AgentEnvironmentCommand::Compact {
+                        worker_id: Uuid::nil(), // Will be filled by UI
+                        instruction,
+                    }))
+                }
+                "usage" => Ok(Command::Ui(UiCommand::Usage)),
+                "context" => Ok(Command::Ui(UiCommand::Context)),
+                "status" => Ok(Command::Ui(UiCommand::Status)),
+                "workers" => Ok(Command::Ui(UiCommand::Workers)),
+                _ => Err(ParseError::UnknownCommand(parts[0].to_string())),
+            }
+        } else {
+            // Implicit /prompt command
+            Ok(Command::Agent(AgentEnvironmentCommand::Prompt {
+                worker_id: Uuid::nil(), // Will be filled by UI
+                text: trimmed.to_string(),
+            }))
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_parse_quit_command() {
+        let cmd = CommandParser::parse("/quit").unwrap();
+        assert!(matches!(
+            cmd,
+            Command::Agent(AgentEnvironmentCommand::Quit)
+        ));
+
+        let cmd = CommandParser::parse("/q").unwrap();
+        assert!(matches!(
+            cmd,
+            Command::Agent(AgentEnvironmentCommand::Quit)
+        ));
+    }
+
+    #[test]
+    fn test_parse_compact_command() {
+        let cmd = CommandParser::parse("/compact").unwrap();
+        match cmd {
+            Command::Agent(AgentEnvironmentCommand::Compact {
+                worker_id,
+                instruction,
+            }) => {
+                assert_eq!(worker_id, Uuid::nil());
+                assert_eq!(instruction, None);
+            }
+            _ => panic!("Expected Compact command"),
+        }
+    }
+
+    #[test]
+    fn test_parse_compact_with_instruction() {
+        let cmd = CommandParser::parse("/compact summarize briefly").unwrap();
+        match cmd {
+            Command::Agent(AgentEnvironmentCommand::Compact {
+                worker_id,
+                instruction,
+            }) => {
+                assert_eq!(worker_id, Uuid::nil());
+                assert_eq!(instruction, Some("summarize briefly".to_string()));
+            }
+            _ => panic!("Expected Compact command"),
+        }
+    }
+
+    #[test]
+    fn test_parse_ui_commands() {
+        let cmd = CommandParser::parse("/usage").unwrap();
+        assert!(matches!(cmd, Command::Ui(UiCommand::Usage)));
+
+        let cmd = CommandParser::parse("/context").unwrap();
+        assert!(matches!(cmd, Command::Ui(UiCommand::Context)));
+
+        let cmd = CommandParser::parse("/status").unwrap();
+        assert!(matches!(cmd, Command::Ui(UiCommand::Status)));
+
+        let cmd = CommandParser::parse("/workers").unwrap();
+        assert!(matches!(cmd, Command::Ui(UiCommand::Workers)));
+    }
+
+    #[test]
+    fn test_parse_implicit_prompt() {
+        let cmd = CommandParser::parse("Hello, world!").unwrap();
+        match cmd {
+            Command::Agent(AgentEnvironmentCommand::Prompt { worker_id, text }) => {
+                assert_eq!(worker_id, Uuid::nil());
+                assert_eq!(text, "Hello, world!");
+            }
+            _ => panic!("Expected Prompt command"),
+        }
+    }
+
+    #[test]
+    fn test_parse_unknown_command() {
+        let result = CommandParser::parse("/unknown");
+        assert!(matches!(result, Err(ParseError::UnknownCommand(_))));
+    }
+
+    #[test]
+    fn test_parse_error_display() {
+        let err = ParseError::UnknownCommand("test".to_string());
+        assert_eq!(format!("{}", err), "Unknown command: test");
+    }
+}
diff --git a/crates/chat-cli/src/agent_env/context_builder.rs b/crates/chat-cli/src/agent_env/context_builder.rs
new file mode 100644
index 000000000..e4ed3b8e2
--- /dev/null
+++ b/crates/chat-cli/src/agent_env/context_builder.rs
@@ -0,0 +1,200 @@
+use eyre::Result;
+
+use super::context_container::ContextContainer;
+use super::model_providers::{ConversationMessage, MessageRole, ModelRequest};
+use crate::cli::chat::message::AssistantMessage;
+use crate::os::Os;
+
+pub struct ContextBuilder;
+
+impl ContextBuilder {
+    pub async fn build_request(
+        context_container: &ContextContainer,
+        os: &Os,
+    ) -> Result<ModelRequest> {
+        let messages = Self::build_messages(context_container)?;
+        let system_prompt = context_container.get_agent_prompt();
+        let context = Self::load_resources(context_container, os).await?;
+
+        Ok(ModelRequest {
+            messages,
+            system_prompt,
+            context,
+            conversation_id: None,
+        })
+    }
+
+    fn build_messages(context_container: &ContextContainer) -> Result<Vec<ConversationMessage>> {
+        let history = context_container.conversation_history.lock().unwrap();
+        let entries = history.get_entries();
+
+        if entries.is_empty() {
+            return Err(eyre::eyre!("No messages in conversation history"));
+        }
+
+        let mut messages = Vec::new();
+
+        for entry in entries {
+            if let Some(user_msg) = &entry.user {
+                messages.push(ConversationMessage {
+                    role: MessageRole::User,
+                    content: user_msg.content_with_context(),
+                });
+            }
+
+            if let Some(assistant_msg) = &entry.assistant {
+                let content = match assistant_msg {
+                    AssistantMessage::Response { content, .. } => content.clone(),
+                    AssistantMessage::ToolUse { content, .. } => content.clone(),
+                };
+
+                messages.push(ConversationMessage {
+                    role: MessageRole::Assistant,
+                    content,
+                });
+            }
+        }
+
+        Ok(messages)
+    }
+
+    async fn load_resources(context_container: &ContextContainer, os: &Os) -> Result<Option<String>> {
+        use glob::glob;
+        
+        let resource_refs = context_container.get_resource_references();
+        
+        if resource_refs.is_empty() {
+            return Ok(None);
+        }
+        
+        let mut content = String::new();
+        
+        for resource_ref in resource_refs {
+            if !resource_ref.starts_with("file://") {
+                continue;
+            }
+            
+            let path = resource_ref.strip_prefix("file://").unwrap();
+            
+            if path.contains('*') {
+                // Glob pattern
+                match glob(path) {
+                    Ok(entries) => {
+                        for entry in entries {
+                            match entry {
+                                Ok(file_path) => {
+                                    if let Ok(file_content) = os.fs.read_to_string(&file_path).await {
+                                        content.push_str(&format!("\n--- {} ---\n", file_path.display()));
+                                        content.push_str(&file_content);
+                                        content.push('\n');
+                                    }
+                                }
+                                Err(_) => continue,
+                            }
+                        }
+                    }
+                    Err(_) => continue,
+                }
+            } else {
+                // Single file
+                if let Ok(file_content) = os.fs.read_to_string(path).await {
+                    content.push_str(&format!("\n--- {} ---\n", path));
+                    content.push_str(&file_content);
+                    content.push('\n');
+                }
+            }
+        }
+        
+        if content.is_empty() {
+            Ok(None)
+        } else {
+            Ok(Some(content))
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::cli::chat::message::UserMessage;
+
+    #[tokio::test]
+    async fn test_build_request_with_full_context() {
+        let os = Os::new().await.unwrap();
+        let container = ContextContainer::new();
+        container.set_agent_prompt("You are a helpful assistant".to_string());
+        
+        container.conversation_history.lock().unwrap()
+            .push_input_message("Hello".to_string());
+        
+        let request = ContextBuilder::build_request(&container, &os).await.unwrap();
+        
+        assert_eq!(request.messages.len(), 1);
+        assert_eq!(request.messages[0].role, MessageRole::User);
+        assert_eq!(request.system_prompt, Some("You are a helpful assistant".to_string()));
+        assert_eq!(request.context, None); // No resources loaded
+    }
+
+    #[tokio::test]
+    async fn test_build_request_empty_history() {
+        let os = Os::new().await.unwrap();
+        let container = ContextContainer::new();
+        
+        let result = ContextBuilder::build_request(&container, &os).await;
+        
+        assert!(result.is_err());
+        assert!(result.unwrap_err().to_string().contains("No messages"));
+    }
+
+    #[tokio::test]
+    async fn test_build_request_no_agent_context() {
+        let os = Os::new().await.unwrap();
+        let container = ContextContainer::new();
+        container.conversation_history.lock().unwrap()
+            .push_input_message("Hello".to_string());
+        
+        let request = ContextBuilder::build_request(&container, &os).await.unwrap();
+        
+        assert_eq!(request.messages.len(), 1);
+        assert_eq!(request.system_prompt, None);
+        assert_eq!(request.context, None);
+    }
+
+    #[tokio::test]
+    async fn test_build_messages_with_assistant_response() {
+        let os = Os::new().await.unwrap();
+        let container = ContextContainer::new();
+        
+        container.conversation_history.lock().unwrap()
+            .push_input_message("Hello".to_string());
+        container.conversation_history.lock().unwrap()
+            .push_assistant_message(AssistantMessage::new_response(None, "Hi there".to_string()));
+        
+        let request = ContextBuilder::build_request(&container, &os).await.unwrap();
+        
+        assert_eq!(request.messages.len(), 2);
+        assert_eq!(request.messages[0].role, MessageRole::User);
+        assert_eq!(request.messages[1].role, MessageRole::Assistant);
+        assert_eq!(request.messages[1].content, "Hi there");
+    }
+
+    #[tokio::test]
+    async fn test_build_messages_with_tool_use() {
+        let os = Os::new().await.unwrap();
+        let container = ContextContainer::new();
+        
+        container.conversation_history.lock().unwrap()
+            .push_input_message("Run command".to_string());
+        container.conversation_history.lock().unwrap()
+            .push_assistant_message(AssistantMessage::new_tool_use(
+                None,
+                "Using tool".to_string(),
+                vec![],
+            ));
+        
+        let request = ContextBuilder::build_request(&container, &os).await.unwrap();
+        
+        assert_eq!(request.messages.len(), 2);
+        assert_eq!(request.messages[1].content, "Using tool");
+    }
+}
diff --git a/crates/chat-cli/src/agent_env/context_container/context_container.rs b/crates/chat-cli/src/agent_env/context_container/context_container.rs
new file mode 100644
index 000000000..ef2f3ddf4
--- /dev/null
+++ b/crates/chat-cli/src/agent_env/context_container/context_container.rs
@@ -0,0 +1,57 @@
+use std::sync::{Arc, Mutex};
+use serde::{Serialize, Deserialize};
+use super::conversation_history::ConversationHistory;
+
+fn default_agent_prompt() -> Arc<Mutex<Option<String>>> {
+    Arc::new(Mutex::new(None))
+}
+
+fn default_resource_references() -> Arc<Mutex<Vec<String>>> {
+    Arc::new(Mutex::new(Vec::new()))
+}
+
+/// Container for all contextual information available to a worker
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ContextContainer {
+    #[serde(skip)]
+    pub conversation_history: Arc<Mutex<ConversationHistory>>,
+    
+    #[serde(skip, default = "default_agent_prompt")]
+    pub agent_prompt: Arc<Mutex<Option<String>>>,
+    
+    /// Resource file paths (file:// URLs) to be loaded when building ModelRequest
+    #[serde(skip, default = "default_resource_references")]
+    pub resource_references: Arc<Mutex<Vec<String>>>,
+}
+
+impl ContextContainer {
+    pub fn new() -> Self {
+        Self {
+            conversation_history: Arc::new(Mutex::new(ConversationHistory::new())),
+            agent_prompt: Arc::new(Mutex::new(None)),
+            resource_references: Arc::new(Mutex::new(Vec::new())),
+        }
+    }
+    
+    pub fn set_agent_prompt(&self, prompt: String) {
+        *self.agent_prompt.lock().unwrap() = Some(prompt);
+    }
+    
+    pub fn get_agent_prompt(&self) -> Option<String> {
+        self.agent_prompt.lock().unwrap().clone()
+    }
+    
+    pub fn set_resource_references(&self, references: Vec<String>) {
+        *self.resource_references.lock().unwrap() = references;
+    }
+    
+    pub fn get_resource_references(&self) -> Vec<String> {
+        self.resource_references.lock().unwrap().clone()
+    }
+}
+
+impl Default for ContextContainer {
+    fn default() -> Self {
+        Self::new()
+    }
+}
diff --git a/crates/chat-cli/src/agent_env/context_container/conversation_entry.rs b/crates/chat-cli/src/agent_env/context_container/conversation_entry.rs
new file mode 100644
index 000000000..f94f7de78
--- /dev/null
+++ b/crates/chat-cli/src/agent_env/context_container/conversation_entry.rs
@@ -0,0 +1,18 @@
+use crate::cli::chat::message::{UserMessage, AssistantMessage};
+
+/// A single message in the conversation (either user input or assistant response)
+#[derive(Debug, Clone)]
+pub struct ConversationEntry {
+    pub user: Option<UserMessage>,
+    pub assistant: Option<AssistantMessage>,
+}
+
+impl ConversationEntry {
+    pub fn new_user(user: UserMessage) -> Self {
+        Self { user: Some(user), assistant: None }
+    }
+    
+    pub fn new_assistant(assistant: AssistantMessage) -> Self {
+        Self { user: None, assistant: Some(assistant) }
+    }
+}
diff --git a/crates/chat-cli/src/agent_env/context_container/conversation_history.rs b/crates/chat-cli/src/agent_env/context_container/conversation_history.rs
new file mode 100644
index 000000000..fdcd13c3f
--- /dev/null
+++ b/crates/chat-cli/src/agent_env/context_container/conversation_history.rs
@@ -0,0 +1,49 @@
+use crate::cli::chat::message::{UserMessage, AssistantMessage};
+use super::conversation_entry::ConversationEntry;
+
+/// Manages conversation history as alternating messages
+#[derive(Debug, Clone)]
+pub struct ConversationHistory {
+    entries: Vec<ConversationEntry>,
+}
+
+impl ConversationHistory {
+    pub fn new() -> Self {
+        Self {
+            entries: Vec::new(),
+        }
+    }
+
+    /// Add an input message to the conversation
+    pub fn push_input_message(&mut self, content: String) {
+        self.entries.push(ConversationEntry::new_user(
+            UserMessage::new_prompt(content, None)
+        ));
+    }
+
+    /// Add an assistant response to the conversation
+    pub fn push_assistant_message(&mut self, assistant: AssistantMessage) {
+        self.entries.push(ConversationEntry::new_assistant(assistant));
+    }
+
+    /// Get all conversation entries
+    pub fn get_entries(&self) -> &[ConversationEntry] {
+        &self.entries
+    }
+
+    /// Get number of entries (individual messages, not turns)
+    pub fn len(&self) -> usize {
+        self.entries.len()
+    }
+
+    /// Check if history is empty
+    pub fn is_empty(&self) -> bool {
+        self.entries.is_empty()
+    }
+}
+
+impl Default for ConversationHistory {
+    fn default() -> Self {
+        Self::new()
+    }
+}
diff --git a/crates/chat-cli/src/agent_env/context_container/mod.rs b/crates/chat-cli/src/agent_env/context_container/mod.rs
new file mode 100644
index 000000000..515a615d0
--- /dev/null
+++ b/crates/chat-cli/src/agent_env/context_container/mod.rs
@@ -0,0 +1,7 @@
+mod conversation_entry;
+mod conversation_history;
+mod context_container;
+
+pub use conversation_entry::ConversationEntry;
+pub use conversation_history::ConversationHistory;
+pub use context_container::ContextContainer;
diff --git a/crates/chat-cli/src/agent_env/event_bus.rs b/crates/chat-cli/src/agent_env/event_bus.rs
new file mode 100644
index 000000000..5d1cc0ffc
--- /dev/null
+++ b/crates/chat-cli/src/agent_env/event_bus.rs
@@ -0,0 +1,113 @@
+//! Central event distribution system using tokio broadcast channels.
+
+use tokio::sync::broadcast;
+use super::events::AgentEnvironmentEvent;
+
+/// Central event distribution system
+#[derive(Clone)]
+pub struct EventBus {
+    sender: broadcast::Sender<AgentEnvironmentEvent>,
+    buffer_size: usize,
+}
+
+impl EventBus {
+    /// Create new EventBus with specified buffer size
+    pub fn new(buffer_size: usize) -> Self {
+        let (sender, _) = broadcast::channel(buffer_size);
+        Self { sender, buffer_size }
+    }
+
+    /// Publish event to all subscribers
+    pub fn publish(&self, event: AgentEnvironmentEvent) {
+        let _ = self.sender.send(event);
+    }
+
+    /// Subscribe to events
+    pub fn subscribe(&self) -> broadcast::Receiver<AgentEnvironmentEvent> {
+        self.sender.subscribe()
+    }
+
+    /// Get current subscriber count
+    pub fn subscriber_count(&self) -> usize {
+        self.sender.receiver_count()
+    }
+}
+
+impl Default for EventBus {
+    fn default() -> Self {
+        Self::new(1000)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::agent_env::events::*;
+    use std::time::Instant;
+    use uuid::Uuid;
+
+    #[tokio::test]
+    async fn test_publish_subscribe_basic() {
+        let bus = EventBus::new(10);
+        let mut receiver = bus.subscribe();
+
+        let event = AgentEnvironmentEvent::System(SystemEvent::ShutdownInitiated {
+            reason: "test".to_string(),
+            timestamp: Instant::now(),
+        });
+
+        bus.publish(event.clone());
+
+        let received = receiver.recv().await.unwrap();
+        assert!(received.is_system_event());
+    }
+
+    #[tokio::test]
+    async fn test_multiple_subscribers() {
+        let bus = EventBus::new(10);
+        let mut receiver1 = bus.subscribe();
+        let mut receiver2 = bus.subscribe();
+        let mut receiver3 = bus.subscribe();
+
+        assert_eq!(bus.subscriber_count(), 3);
+
+        let event = AgentEnvironmentEvent::Worker(WorkerEvent::Created {
+            worker_id: Uuid::new_v4(),
+            name: "test".to_string(),
+            timestamp: Instant::now(),
+        });
+
+        bus.publish(event.clone());
+
+        let r1 = receiver1.recv().await.unwrap();
+        let r2 = receiver2.recv().await.unwrap();
+        let r3 = receiver3.recv().await.unwrap();
+
+        assert!(r1.is_worker_event());
+        assert!(r2.is_worker_event());
+        assert!(r3.is_worker_event());
+    }
+
+    #[tokio::test]
+    async fn test_lagged_events() {
+        let bus = EventBus::new(10);
+        let mut receiver = bus.subscribe();
+
+        for i in 0..100 {
+            let event = AgentEnvironmentEvent::System(SystemEvent::ShutdownInitiated {
+                reason: format!("test {}", i),
+                timestamp: Instant::now(),
+            });
+            bus.publish(event);
+        }
+
+        match receiver.recv().await {
+            Err(tokio::sync::broadcast::error::RecvError::Lagged(_)) => {
+                // Expected - buffer overflow
+            }
+            _ => {
+                // Also acceptable - might receive some events
+            }
+        }
+    }
+}
diff --git a/crates/chat-cli/src/agent_env/events.rs b/crates/chat-cli/src/agent_env/events.rs
new file mode 100644
index 000000000..8bd74c3d4
--- /dev/null
+++ b/crates/chat-cli/src/agent_env/events.rs
@@ -0,0 +1,344 @@
+//! Event types for the Agent Environment system.
+//!
+//! This module defines all event types that flow through the EventBus.
+//! Events are organized in a nested enum structure for clear categorization:
+//! - Worker events: lifecycle and state changes
+//! - Job events: execution lifecycle and output
+//! - AgentLoop events: task-specific events
+//! - System events: system-level notifications
+
+use std::collections::HashMap;
+use std::time::Instant;
+use uuid::Uuid;
+
+/// Worker lifecycle states (managed by Session)
+#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize, Default)]
+pub enum WorkerLifecycleState {
+    /// Worker is idle and ready to accept new jobs
+    #[default]
+    Idle,
+    /// Worker is currently executing a job
+    Busy,
+    /// Worker completed a job with failure
+    IdleFailed,
+}
+
+/// Indicates if a completed job requires user interaction to continue
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum UserInteractionRequired {
+    /// No user interaction required - job completed cleanly
+    None,
+    /// Job is waiting for tool approval from user
+    ToolApproval,
+}
+
+/// Job completion results
+#[derive(Debug, Clone)]
+pub enum JobCompletionResult {
+    /// Job completed successfully
+    Success {
+        task_metadata: HashMap<String, serde_json::Value>,
+        user_interaction_required: UserInteractionRequired,
+    },
+    /// Job was cancelled
+    Cancelled,
+    /// Job failed with an error
+    Failed {
+        error: String,
+    },
+}
+
+/// Output chunk types
+#[derive(Debug, Clone)]
+pub enum OutputChunk {
+    /// Text response from the assistant
+    AssistantResponse(String),
+    /// Tool use request from the assistant
+    ToolUse {
+        tool_name: String,
+        tool_input: serde_json::Value,
+    },
+    /// Result from tool execution
+    ToolResult {
+        tool_name: String,
+        result: String,
+    },
+}
+
+/// Worker lifecycle and state events
+#[derive(Debug, Clone)]
+pub enum WorkerEvent {
+    /// Worker was created
+    Created {
+        worker_id: Uuid,
+        name: String,
+        timestamp: Instant,
+    },
+    /// Worker was deleted
+    Deleted {
+        worker_id: Uuid,
+        timestamp: Instant,
+    },
+    /// Worker lifecycle state changed
+    LifecycleStateChanged {
+        worker_id: Uuid,
+        old_state: WorkerLifecycleState,
+        new_state: WorkerLifecycleState,
+        timestamp: Instant,
+    },
+}
+
+/// Job execution events
+#[derive(Debug, Clone)]
+pub enum JobEvent {
+    /// Job started execution
+    Started {
+        worker_id: Uuid,
+        job_id: Uuid,
+        task_type: String,
+        timestamp: Instant,
+    },
+    /// Job completed execution
+    Completed {
+        worker_id: Uuid,
+        job_id: Uuid,
+        result: JobCompletionResult,
+        timestamp: Instant,
+    },
+    /// Job produced an output chunk
+    OutputChunk {
+        worker_id: Uuid,
+        job_id: Uuid,
+        chunk: OutputChunk,
+        timestamp: Instant,
+    },
+}
+
+/// AgentLoop-specific events
+#[derive(Debug, Clone)]
+pub enum AgentLoopEvent {
+    /// AgentLoop received a complete response from the LLM
+    ResponseReceived {
+        worker_id: Uuid,
+        job_id: Uuid,
+        text: String,
+        timestamp: Instant,
+    },
+    /// AgentLoop received a tool use request from the LLM
+    ToolUseRequestReceived {
+        worker_id: Uuid,
+        job_id: Uuid,
+        tool_name: String,
+        tool_input: serde_json::Value,
+        timestamp: Instant,
+    },
+}
+
+/// System-level events
+#[derive(Debug, Clone)]
+pub enum SystemEvent {
+    /// System shutdown was initiated
+    ShutdownInitiated {
+        reason: String,
+        timestamp: Instant,
+    },
+}
+
+/// WebUI-specific events
+#[derive(Debug, Clone)]
+pub enum WebUIEvent {
+    /// User sent a prompt through WebUI
+    PromptReceived {
+        worker_id: Uuid,
+        text: String,
+        timestamp: Instant,
+    },
+    /// Web server started
+    ServerStarted {
+        address: String,
+        timestamp: Instant,
+    },
+    /// Client connected to WebSocket
+    WebSocketConnected {
+        timestamp: Instant,
+    },
+}
+
+/// Top-level event envelope
+#[derive(Debug, Clone)]
+pub enum AgentEnvironmentEvent {
+    /// Worker-related event
+    Worker(WorkerEvent),
+    /// Job-related event
+    Job(JobEvent),
+    /// AgentLoop-specific event
+    AgentLoop(AgentLoopEvent),
+    /// System-level event
+    System(SystemEvent),
+    /// WebUI-specific event
+    WebUI(WebUIEvent),
+}
+
+impl AgentEnvironmentEvent {
+    /// Extract worker_id from any event that has one
+    pub fn worker_id(&self) -> Option<Uuid> {
+        match self {
+            Self::Worker(WorkerEvent::Created { worker_id, .. }) => Some(*worker_id),
+            Self::Worker(WorkerEvent::Deleted { worker_id, .. }) => Some(*worker_id),
+            Self::Worker(WorkerEvent::LifecycleStateChanged { worker_id, .. }) => Some(*worker_id),
+            Self::Job(JobEvent::Started { worker_id, .. }) => Some(*worker_id),
+            Self::Job(JobEvent::Completed { worker_id, .. }) => Some(*worker_id),
+            Self::Job(JobEvent::OutputChunk { worker_id, .. }) => Some(*worker_id),
+            Self::AgentLoop(AgentLoopEvent::ResponseReceived { worker_id, .. }) => Some(*worker_id),
+            Self::AgentLoop(AgentLoopEvent::ToolUseRequestReceived { worker_id, .. }) => Some(*worker_id),
+            Self::WebUI(WebUIEvent::PromptReceived { worker_id, .. }) => Some(*worker_id),
+            Self::WebUI(WebUIEvent::ServerStarted { .. }) => None,
+            Self::WebUI(WebUIEvent::WebSocketConnected { .. }) => None,
+            Self::System(_) => None,
+        }
+    }
+
+    /// Check if this is a worker-related event
+    pub fn is_worker_event(&self) -> bool {
+        matches!(self, Self::Worker(_))
+    }
+
+    /// Check if this is a job-related event
+    pub fn is_job_event(&self) -> bool {
+        matches!(self, Self::Job(_))
+    }
+
+    /// Check if this is an agent loop event
+    pub fn is_agent_loop_event(&self) -> bool {
+        matches!(self, Self::AgentLoop(_))
+    }
+
+    /// Check if this is a system event
+    pub fn is_system_event(&self) -> bool {
+        matches!(self, Self::System(_))
+    }
+
+    /// Check if this is a WebUI event
+    pub fn is_webui_event(&self) -> bool {
+        matches!(self, Self::WebUI(_))
+    }
+
+    /// Get timestamp from any event
+    pub fn timestamp(&self) -> Instant {
+        match self {
+            Self::Worker(WorkerEvent::Created { timestamp, .. }) => *timestamp,
+            Self::Worker(WorkerEvent::Deleted { timestamp, .. }) => *timestamp,
+            Self::Worker(WorkerEvent::LifecycleStateChanged { timestamp, .. }) => *timestamp,
+            Self::Job(JobEvent::Started { timestamp, .. }) => *timestamp,
+            Self::Job(JobEvent::Completed { timestamp, .. }) => *timestamp,
+            Self::Job(JobEvent::OutputChunk { timestamp, .. }) => *timestamp,
+            Self::AgentLoop(AgentLoopEvent::ResponseReceived { timestamp, .. }) => *timestamp,
+            Self::AgentLoop(AgentLoopEvent::ToolUseRequestReceived { timestamp, .. }) => *timestamp,
+            Self::System(SystemEvent::ShutdownInitiated { timestamp, .. }) => *timestamp,
+            Self::WebUI(WebUIEvent::PromptReceived { timestamp, .. }) => *timestamp,
+            Self::WebUI(WebUIEvent::ServerStarted { timestamp, .. }) => *timestamp,
+            Self::WebUI(WebUIEvent::WebSocketConnected { timestamp, .. }) => *timestamp,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_worker_id_extraction() {
+        let worker_id = Uuid::new_v4();
+        let timestamp = Instant::now();
+
+        let event = AgentEnvironmentEvent::Worker(WorkerEvent::Created {
+            worker_id,
+            name: "test".to_string(),
+            timestamp,
+        });
+        assert_eq!(event.worker_id(), Some(worker_id));
+
+        let event = AgentEnvironmentEvent::Job(JobEvent::Started {
+            worker_id,
+            job_id: Uuid::new_v4(),
+            task_type: "test".to_string(),
+            timestamp,
+        });
+        assert_eq!(event.worker_id(), Some(worker_id));
+
+        let event = AgentEnvironmentEvent::System(SystemEvent::ShutdownInitiated {
+            reason: "test".to_string(),
+            timestamp,
+        });
+        assert_eq!(event.worker_id(), None);
+    }
+
+    #[test]
+    fn test_event_type_checking() {
+        let timestamp = Instant::now();
+
+        let event = AgentEnvironmentEvent::Worker(WorkerEvent::Created {
+            worker_id: Uuid::new_v4(),
+            name: "test".to_string(),
+            timestamp,
+        });
+        assert!(event.is_worker_event());
+        assert!(!event.is_job_event());
+        assert!(!event.is_agent_loop_event());
+        assert!(!event.is_system_event());
+
+        let event = AgentEnvironmentEvent::Job(JobEvent::Started {
+            worker_id: Uuid::new_v4(),
+            job_id: Uuid::new_v4(),
+            task_type: "test".to_string(),
+            timestamp,
+        });
+        assert!(!event.is_worker_event());
+        assert!(event.is_job_event());
+
+        let event = AgentEnvironmentEvent::System(SystemEvent::ShutdownInitiated {
+            reason: "test".to_string(),
+            timestamp,
+        });
+        assert!(event.is_system_event());
+    }
+
+    #[test]
+    fn test_timestamp_extraction() {
+        let timestamp = Instant::now();
+
+        let event = AgentEnvironmentEvent::Worker(WorkerEvent::Created {
+            worker_id: Uuid::new_v4(),
+            name: "test".to_string(),
+            timestamp,
+        });
+        assert_eq!(event.timestamp(), timestamp);
+
+        let event = AgentEnvironmentEvent::Job(JobEvent::Completed {
+            worker_id: Uuid::new_v4(),
+            job_id: Uuid::new_v4(),
+            result: JobCompletionResult::Success {
+                task_metadata: std::collections::HashMap::new(),
+                user_interaction_required: UserInteractionRequired::None,
+            },
+            timestamp,
+        });
+        assert_eq!(event.timestamp(), timestamp);
+    }
+
+    #[test]
+    fn test_user_interaction_required_enum() {
+        // Test enum variants can be constructed
+        let none = UserInteractionRequired::None;
+        let tool_approval = UserInteractionRequired::ToolApproval;
+
+        // Test PartialEq implementation
+        assert_eq!(none, UserInteractionRequired::None);
+        assert_eq!(tool_approval, UserInteractionRequired::ToolApproval);
+        assert_ne!(none, tool_approval);
+
+        // Test Copy trait
+        let none_copy = none;
+        assert_eq!(none, none_copy);
+    }
+}
diff --git a/crates/chat-cli/src/agent_env/mod.rs b/crates/chat-cli/src/agent_env/mod.rs
new file mode 100644
index 000000000..d37350b42
--- /dev/null
+++ b/crates/chat-cli/src/agent_env/mod.rs
@@ -0,0 +1,33 @@
+// Core modules
+pub mod events;
+pub mod event_bus;
+pub mod commands;
+pub mod agent_environment;
+pub mod worker_job_continuations;
+pub mod model_providers;
+pub mod context_container;
+pub mod context_builder;
+pub mod worker_builder;
+pub mod worker;
+pub mod worker_task;
+pub mod worker_job;
+pub mod session;
+
+// Task implementations
+pub mod worker_tasks;
+
+// Re-exports for convenience
+pub use events::*;
+pub use event_bus::EventBus;
+pub use commands::*;
+pub use agent_environment::{AgentEnvironment, UserInterface, HeadlessInterface};
+pub use worker_job_continuations::{Continuations, WorkerJobCompletionType};
+pub use model_providers::{
+    ModelProvider, ModelRequest, ModelResponse, ModelResponseChunk,
+};
+pub use context_container::{ContextContainer, ConversationHistory, ConversationEntry};
+pub use context_builder::ContextBuilder;
+pub use worker_builder::WorkerBuilder;
+pub use worker::{Worker, WorkerStates};
+pub use worker_task::WorkerTask;
+pub use session::Session;
diff --git a/crates/chat-cli/src/agent_env/model_providers/bedrock_converse_stream.rs b/crates/chat-cli/src/agent_env/model_providers/bedrock_converse_stream.rs
new file mode 100644
index 000000000..b7661307f
--- /dev/null
+++ b/crates/chat-cli/src/agent_env/model_providers/bedrock_converse_stream.rs
@@ -0,0 +1,137 @@
+use aws_sdk_bedrockruntime::{Client as BedrockClient, types::{Message, ConversationRole, ContentBlock, SystemContentBlock}};
+use tokio_util::sync::CancellationToken;
+
+use super::model_provider::*;
+
+#[derive(Clone)]
+pub struct BedrockConverseStreamModelProvider {
+    client: BedrockClient,
+    model_id: String,
+}
+
+impl BedrockConverseStreamModelProvider {
+    pub fn new(client: BedrockClient) -> Self {
+        Self {
+            client,
+            model_id: "us.anthropic.claude-sonnet-4-20250514-v1:0".to_string(),
+        }
+    }
+}
+
+#[async_trait::async_trait]
+impl ModelProvider for BedrockConverseStreamModelProvider {
+    async fn request(
+        &self,
+        request: ModelRequest,
+        when_receiving_begin: Box<dyn Fn() + Send>,
+        when_received: Box<dyn Fn(ModelResponseChunk) + Send>,
+        cancellation_token: CancellationToken,
+    ) -> Result<ModelResponse, eyre::Error> {
+        // Build system content blocks
+        let mut system_blocks = Vec::new();
+        if let Some(prompt) = request.system_prompt {
+            system_blocks.push(SystemContentBlock::Text(prompt));
+        }
+        if let Some(context) = request.context {
+            system_blocks.push(SystemContentBlock::Text(context));
+        }
+
+        // Convert messages to Bedrock format
+        let messages: Vec<Message> = request.messages
+            .iter()
+            .map(|msg| {
+                let role = match msg.role {
+                    MessageRole::User => ConversationRole::User,
+                    MessageRole::Assistant => ConversationRole::Assistant,
+                };
+                Message::builder()
+                    .role(role)
+                    .content(ContentBlock::Text(msg.content.clone()))
+                    .build()
+                    .unwrap()
+            })
+            .collect();
+
+        // Build request
+        let mut request_builder = self.client
+            .converse_stream()
+            .model_id(&self.model_id)
+            .set_messages(Some(messages));
+
+        if !system_blocks.is_empty() {
+            request_builder = request_builder.set_system(Some(system_blocks));
+        }
+
+        let response = tokio::select! {
+            result = request_builder.send() => {
+                match result {
+                    Ok(r) => r,
+                    Err(e) => {
+                        eprintln!("AWS Bedrock request failed:");
+                        eprintln!("  Model ID: {}", self.model_id);
+                        eprintln!("  Error type: {:?}", e);
+                        eprintln!("  Error message: {}", e);
+                        
+                        if e.to_string().contains("dispatch failure") {
+                            eprintln!("  Likely causes:");
+                            eprintln!("    - AWS credentials not configured");
+                            eprintln!("    - Network connectivity issues");
+                            eprintln!("    - AWS region not set or incorrect");
+                            eprintln!("    - Bedrock service not available in region");
+                        }
+                        
+                        return Err(eyre::eyre!("Bedrock request failed: {}", e));
+                    }
+                }
+            },
+            _ = cancellation_token.cancelled() => {
+                return Err(eyre::eyre!("Request cancelled"));
+            }
+        };
+
+        when_receiving_begin();
+        let mut accumulated_content = String::new();
+        let mut stream = response.stream;
+
+        loop {
+            let event = tokio::select! {
+                event = stream.recv() => event,
+                _ = cancellation_token.cancelled() => {
+                    println!("Model request cancelled during streaming");
+                    return Err(eyre::eyre!("Request cancelled"));
+                }
+            };
+
+            match event {
+                Ok(Some(output)) => {
+                    if cancellation_token.is_cancelled() {
+                        println!("Model request cancelled during chunk processing");
+                        return Err(eyre::eyre!("Request cancelled"));
+                    }
+                    
+                    match output {
+                        aws_sdk_bedrockruntime::types::ConverseStreamOutput::ContentBlockDelta(delta) => {
+                            if let Some(delta_content) = delta.delta {
+                                if let aws_sdk_bedrockruntime::types::ContentBlockDelta::Text(text) = delta_content {
+                                    accumulated_content.push_str(&text);
+                                    when_received(ModelResponseChunk::AssistantMessage(text));
+                                }
+                            }
+                        }
+                        aws_sdk_bedrockruntime::types::ConverseStreamOutput::MessageStop(_) => {
+                            break;
+                        }
+                        _ => {}
+                    }
+                }
+                Ok(None) => break,
+                Err(e) => return Err(eyre::eyre!("Stream error: {}", e)),
+            }
+        }
+
+        Ok(ModelResponse {
+            content: accumulated_content,
+            tool_requests: Vec::new(),
+        })
+    }
+}
diff --git a/crates/chat-cli/src/agent_env/model_providers/codewhisperer.rs b/crates/chat-cli/src/agent_env/model_providers/codewhisperer.rs
new file mode 100644
index 000000000..f270a64e8
--- /dev/null
+++ b/crates/chat-cli/src/agent_env/model_providers/codewhisperer.rs
@@ -0,0 +1,406 @@
+use amzn_codewhisperer_streaming_client::Client as CodeWhispererStreamingClient;
+use amzn_codewhisperer_streaming_client::types::*;
+use std::sync::Arc;
+use async_trait::async_trait;
+use eyre::Result;
+use tokio_util::sync::CancellationToken;
+
+use super::model_provider::*;
+
+pub struct CodeWhispererModelProvider {
+    client: Arc<CodeWhispererStreamingClient>,
+}
+
+impl CodeWhispererModelProvider {
+    pub fn new(client: CodeWhispererStreamingClient) -> Self {
+        Self {
+            client: Arc::new(client),
+        }
+    }
+
+    fn process_stream_event(
+        &self,
+        event: ChatResponseStream,
+        accumulated_content: &mut String,
+        tool_requests: &mut Vec<ToolRequest>,
+        when_received: &dyn Fn(ModelResponseChunk),
+    ) -> Result<()> {
+        match event {
+            ChatResponseStream::AssistantResponseEvent(evt) => {
+                accumulated_content.push_str(&evt.content);
+                when_received(ModelResponseChunk::AssistantMessage(evt.content));
+            }
+            
+            ChatResponseStream::ToolUseEvent(evt) => {
+                // ToolUseEvent has fields: tool_use_id (String), name (String), input (Option<Document>)
+                if let Some(input) = evt.input {
+                    let parameters = serde_json::to_string(&input)
+                        .unwrap_or_else(|_| "{}".to_string());
+                    
+                    tool_requests.push(ToolRequest {
+                        tool_name: evt.name.clone(),
+                        parameters: parameters.clone(),
+                    });
+                    
+                    when_received(ModelResponseChunk::ToolUseRequest {
+                        tool_name: evt.name,
+                        parameters,
+                    });
+                }
+            }
+            
+            // Ignore other events for MVP
+            _ => {}
+        }
+        
+        Ok(())
+    }
+}
+
+#[async_trait]
+impl ModelProvider for CodeWhispererModelProvider {
+    async fn request(
+        &self,
+        request: ModelRequest,
+        when_receiving_begin: Box<dyn Fn() + Send>,
+        when_received: Box<dyn Fn(ModelResponseChunk) + Send>,
+        cancellation_token: CancellationToken,
+    ) -> Result<ModelResponse, eyre::Error> {
+        // Split messages into history and current message
+        if request.messages.is_empty() {
+            return Err(eyre::eyre!("No messages in request"));
+        }
+        
+        let mut history_messages = Vec::new();
+        
+        // All messages except the last go into history
+        if request.messages.len() > 1 {
+            for i in 0..request.messages.len() - 1 {
+                let msg = &request.messages[i];
+                match msg.role {
+                    MessageRole::User => {
+                        let user_msg = UserInputMessage::builder()
+                            .content(msg.content.clone())
+                            .build()
+                            .map_err(|e| eyre::eyre!("Failed to build UserInputMessage: {}", e))?;
+                        history_messages.push(ChatMessage::UserInputMessage(user_msg));
+                    }
+                    MessageRole::Assistant => {
+                        let assistant_msg = AssistantResponseMessage::builder()
+                            .content(msg.content.clone())
+                            .build()
+                            .map_err(|e| eyre::eyre!("Failed to build AssistantResponseMessage: {}", e))?;
+                        history_messages.push(ChatMessage::AssistantResponseMessage(assistant_msg));
+                    }
+                }
+            }
+        }
+        
+        // Last message becomes current message
+        let last_msg = request.messages.last().unwrap();
+        if last_msg.role != MessageRole::User {
+            return Err(eyre::eyre!("Last message must be from user"));
+        }
+        
+        // Build current message content, prepending system prompt and context if present
+        let mut content = String::new();
+        if let Some(prompt) = request.system_prompt {
+            content.push_str(&prompt);
+            content.push_str("\n\n");
+        }
+        if let Some(ctx) = request.context {
+            content.push_str(&ctx);
+            content.push_str("\n\n");
+        }
+        content.push_str(&last_msg.content);
+        
+        // Build current user message
+        let user_message = UserInputMessage::builder()
+            .content(content)
+            .build()
+            .map_err(|e| eyre::eyre!("Failed to build UserInputMessage: {}", e))?;
+        
+        // Build conversation state with history
+        let conversation_id = request.conversation_id
+            .unwrap_or_else(|| uuid::Uuid::new_v4().to_string());
+        
+        let mut conversation_state_builder = ConversationState::builder()
+            .current_message(ChatMessage::UserInputMessage(user_message))
+            .chat_trigger_type(ChatTriggerType::Manual)
+            .conversation_id(conversation_id);
+        
+        if !history_messages.is_empty() {
+            conversation_state_builder = conversation_state_builder.set_history(Some(history_messages));
+        }
+        
+        let conversation_state = conversation_state_builder
+            .build()
+            .map_err(|e| eyre::eyre!("Failed to build ConversationState: {}", e))?;
+        
+        // 3. Send request with cancellation support
+        let response = tokio::select! {
+            result = self.client
+                .send_message()
+                .conversation_state(conversation_state)
+                .send() => {
+                match result {
+                    Ok(r) => r,
+                    Err(e) => {
+                        eprintln!("CodeWhisperer request failed:");
+                        eprintln!("  Error: {}", e);
+                        
+                        // Provide context-specific guidance
+                        if e.to_string().contains("authentication") {
+                            eprintln!("  Likely cause: Invalid or expired token");
+                            eprintln!("  Solution: Run 'q login' to re-authenticate");
+                        } else if e.to_string().contains("rate limit") {
+                            eprintln!("  Likely cause: Rate limit exceeded");
+                            eprintln!("  Solution: Wait a moment and try again");
+                        }
+                        
+                        return Err(eyre::eyre!("CodeWhisperer request failed: {}", e));
+                    }
+                }
+            },
+            _ = cancellation_token.cancelled() => {
+                return Err(eyre::eyre!("Request cancelled"));
+            }
+        };
+        
+        // 3. Signal receiving started
+        when_receiving_begin();
+        
+        // 4. Process stream
+        let mut accumulated_content = String::new();
+        let mut tool_requests: Vec<ToolRequest> = Vec::new();
+        let mut stream = response.send_message_response;
+        
+        loop {
+            let event = tokio::select! {
+                event = stream.recv() => event,
+                _ = cancellation_token.cancelled() => {
+                    return Err(eyre::eyre!("Request cancelled"));
+                }
+            };
+            
+            match event {
+                Ok(Some(stream_event)) => {
+                    if cancellation_token.is_cancelled() {
+                        return Err(eyre::eyre!("Request cancelled"));
+                    }
+                    
+                    self.process_stream_event(
+                        stream_event,
+                        &mut accumulated_content,
+                        &mut tool_requests,
+                        &when_received,
+                    )?;
+                }
+                Ok(None) => break,  // Stream ended
+                Err(e) => return Err(eyre::eyre!("Stream error: {}", e)),
+            }
+        }
+        
+        // 5. Return final response
+        Ok(ModelResponse {
+            content: accumulated_content,
+            tool_requests,
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::sync::Mutex;
+
+    #[test]
+    fn test_conversation_state_with_history() {
+        let request = ModelRequest {
+            messages: vec![
+                ConversationMessage {
+                    role: MessageRole::User,
+                    content: "First message".to_string(),
+                },
+                ConversationMessage {
+                    role: MessageRole::Assistant,
+                    content: "First response".to_string(),
+                },
+                ConversationMessage {
+                    role: MessageRole::User,
+                    content: "Second message".to_string(),
+                },
+            ],
+            system_prompt: None,
+            context: None,
+            conversation_id: Some("test-conv-123".to_string()),
+        };
+        
+        // Verify we have 3 messages total
+        assert_eq!(request.messages.len(), 3);
+        
+        // Last message should be User
+        assert_eq!(request.messages.last().unwrap().role, MessageRole::User);
+        
+        // First two should go into history
+        assert_eq!(request.messages.len() - 1, 2);
+    }
+    
+    #[test]
+    fn test_conversation_state_single_message() {
+        let request = ModelRequest {
+            messages: vec![
+                ConversationMessage {
+                    role: MessageRole::User,
+                    content: "Hello".to_string(),
+                },
+            ],
+            system_prompt: None,
+            context: None,
+            conversation_id: Some("test-conv-123".to_string()),
+        };
+        
+        // Single message, no history
+        assert_eq!(request.messages.len(), 1);
+    }
+    
+    #[test]
+    fn test_system_prompt_and_context_prepended() {
+        let request = ModelRequest {
+            messages: vec![
+                ConversationMessage {
+                    role: MessageRole::User,
+                    content: "User question".to_string(),
+                },
+            ],
+            system_prompt: Some("System prompt".to_string()),
+            context: Some("Context data".to_string()),
+            conversation_id: None,
+        };
+        
+        // Verify fields are present
+        assert!(request.system_prompt.is_some());
+        assert!(request.context.is_some());
+    }
+
+    #[test]
+    fn test_conversation_id_generation_without_provided_id() {
+        let request = ModelRequest {
+            messages: vec![ConversationMessage {
+                role: MessageRole::User,
+                content: "Hello".to_string(),
+            }],
+            system_prompt: None,
+            context: None,
+            conversation_id: None,
+        };
+        
+        let conversation_id = request.conversation_id
+            .unwrap_or_else(|| uuid::Uuid::new_v4().to_string());
+        
+        assert_eq!(conversation_id.len(), 36);
+        assert!(conversation_id.contains('-'));
+        assert!(uuid::Uuid::parse_str(&conversation_id).is_ok());
+    }
+
+    #[test]
+    fn test_process_assistant_response_event() {
+        // Create test event
+        let event = ChatResponseStream::AssistantResponseEvent(
+            AssistantResponseEvent::builder()
+                .content("Hello world")
+                .build()
+                .unwrap()
+        );
+        
+        let mut accumulated_content = String::new();
+        let mut tool_requests: Vec<ToolRequest> = Vec::new();
+        let received_chunks = Arc::new(Mutex::new(Vec::new()));
+        let received_chunks_clone = received_chunks.clone();
+        
+        let when_received = move |chunk: ModelResponseChunk| {
+            received_chunks_clone.lock().unwrap().push(chunk);
+        };
+        
+        // Process event directly without needing a provider instance
+        match event {
+            ChatResponseStream::AssistantResponseEvent(evt) => {
+                accumulated_content.push_str(&evt.content);
+                when_received(ModelResponseChunk::AssistantMessage(evt.content));
+            }
+            _ => {}
+        }
+        
+        // Verify accumulated content
+        assert_eq!(accumulated_content, "Hello world");
+        
+        // Verify callback was called
+        let chunks = received_chunks.lock().unwrap();
+        assert_eq!(chunks.len(), 1);
+        match &chunks[0] {
+            ModelResponseChunk::AssistantMessage(msg) => assert_eq!(msg, "Hello world"),
+            _ => panic!("Expected AssistantMessage chunk"),
+        }
+    }
+
+    #[test]
+    fn test_process_tool_use_event() {
+        // Create test tool use event with JSON string input
+        let input_json = r#"{"path":"/tmp/test.txt"}"#;
+        
+        let event = ChatResponseStream::ToolUseEvent(
+            ToolUseEvent::builder()
+                .tool_use_id("tool-123")
+                .name("fs_read")
+                .input(input_json)
+                .build()
+                .unwrap()
+        );
+        
+        let mut accumulated_content = String::new();
+        let mut tool_requests: Vec<ToolRequest> = Vec::new();
+        let received_chunks = Arc::new(Mutex::new(Vec::new()));
+        let received_chunks_clone = received_chunks.clone();
+        
+        let when_received = move |chunk: ModelResponseChunk| {
+            received_chunks_clone.lock().unwrap().push(chunk);
+        };
+        
+        // Process event directly
+        match event {
+            ChatResponseStream::ToolUseEvent(evt) => {
+                if let Some(input) = evt.input {
+                    let parameters = input;
+                    
+                    tool_requests.push(ToolRequest {
+                        tool_name: evt.name.clone(),
+                        parameters: parameters.clone(),
+                    });
+                    
+                    when_received(ModelResponseChunk::ToolUseRequest {
+                        tool_name: evt.name,
+                        parameters,
+                    });
+                }
+            }
+            _ => {}
+        }
+        
+        // Verify tool request was added
+        assert_eq!(tool_requests.len(), 1);
+        assert_eq!(tool_requests[0].tool_name, "fs_read");
+        assert!(tool_requests[0].parameters.contains("path"));
+        assert!(tool_requests[0].parameters.contains("/tmp/test.txt"));
+        
+        // Verify callback was called
+        let chunks = received_chunks.lock().unwrap();
+        assert_eq!(chunks.len(), 1);
+        match &chunks[0] {
+            ModelResponseChunk::ToolUseRequest { tool_name, parameters } => {
+                assert_eq!(tool_name, "fs_read");
+                assert!(parameters.contains("path"));
+            },
+            _ => panic!("Expected ToolUseRequest chunk"),
+        }
+    }
+}
diff --git a/crates/chat-cli/src/agent_env/model_providers/mod.rs b/crates/chat-cli/src/agent_env/model_providers/mod.rs
new file mode 100644
index 000000000..814db951b
--- /dev/null
+++ b/crates/chat-cli/src/agent_env/model_providers/mod.rs
@@ -0,0 +1,7 @@
+mod model_provider;
+pub mod bedrock_converse_stream;
+pub mod codewhisperer;
+
+pub use model_provider::*;
+pub use bedrock_converse_stream::BedrockConverseStreamModelProvider;
+pub use codewhisperer::CodeWhispererModelProvider;
diff --git a/crates/chat-cli/src/agent_env/model_providers/model_provider.rs b/crates/chat-cli/src/agent_env/model_providers/model_provider.rs
new file mode 100644
index 000000000..e2a6c1fdb
--- /dev/null
+++ b/crates/chat-cli/src/agent_env/model_providers/model_provider.rs
@@ -0,0 +1,50 @@
+use tokio_util::sync::CancellationToken;
+
+#[derive(Debug, Clone)]
+pub struct ModelRequest {
+    pub messages: Vec<ConversationMessage>,
+    pub system_prompt: Option<String>,
+    pub context: Option<String>,
+    pub conversation_id: Option<String>,
+}
+
+#[derive(Debug, Clone)]
+pub struct ConversationMessage {
+    pub role: MessageRole,
+    pub content: String,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum MessageRole {
+    User,
+    Assistant,
+}
+
+#[derive(Debug, Clone)]
+pub enum ModelResponseChunk {
+    AssistantMessage(String),
+    ToolUseRequest { tool_name: String, parameters: String },
+}
+
+#[derive(Debug, Clone)]
+pub struct ModelResponse {
+    pub content: String,
+    pub tool_requests: Vec<ToolRequest>,
+}
+
+#[derive(Debug, Clone)]
+pub struct ToolRequest {
+    pub tool_name: String,
+    pub parameters: String,
+}
+
+#[async_trait::async_trait]
+pub trait ModelProvider: Send + Sync {
+    async fn request(
+        &self,
+        request: ModelRequest,
+        when_receiving_begin: Box<dyn Fn() + Send>,
+        when_received: Box<dyn Fn(ModelResponseChunk) + Send>,
+        cancellation_token: CancellationToken,
+    ) -> Result<ModelResponse, eyre::Error>;
+}
diff --git a/crates/chat-cli/src/agent_env/session.rs b/crates/chat-cli/src/agent_env/session.rs
new file mode 100644
index 000000000..9bbe8bcfd
--- /dev/null
+++ b/crates/chat-cli/src/agent_env/session.rs
@@ -0,0 +1,683 @@
+use std::sync::{Arc, Mutex};
+use std::time::{Duration, Instant};
+use tokio_util::sync::CancellationToken;
+use tracing::error;
+use uuid::Uuid;
+
+use super::worker::Worker;
+use super::worker_job::WorkerJob;
+use super::worker_task::WorkerTask;
+use super::model_providers::ModelProvider;
+use super::worker_tasks::{AgentLoop, AgentLoopInput};
+use super::event_bus::EventBus;
+use super::events::{AgentEnvironmentEvent, JobEvent, WorkerEvent, WorkerLifecycleState, UserInteractionRequired};
+
+/// Maximum number of inactive jobs to keep in memory
+pub const MAX_INACTIVE_JOBS: usize = 3;
+
+#[derive(Clone)]
+pub struct Session {
+    event_bus: EventBus,
+    model_providers: Vec<Arc<dyn ModelProvider>>,
+    workers: Arc<Mutex<Vec<Arc<Worker>>>>,
+    jobs: Arc<Mutex<Vec<Arc<WorkerJob>>>>,
+    os: Option<Arc<crate::os::Os>>,
+}
+
+impl Session {
+    pub fn new(event_bus: EventBus, model_providers: Vec<Arc<dyn ModelProvider>>) -> Self {
+        Self {
+            event_bus,
+            model_providers,
+            workers: Arc::new(Mutex::new(Vec::new())),
+            jobs: Arc::new(Mutex::new(Vec::new())),
+            os: None,
+        }
+    }
+    
+    pub fn with_os(mut self, os: Arc<crate::os::Os>) -> Self {
+        self.os = Some(os);
+        self
+    }
+
+    pub fn event_bus(&self) -> &EventBus {
+        &self.event_bus
+    }
+
+    pub fn build_worker(&self, name: String) -> Arc<Worker> {
+        let model_provider = self.model_providers.first()
+            .expect("At least one model provider required")
+            .clone();
+        
+        let worker = Arc::new(Worker::new(
+            name.clone(),
+            model_provider,
+        ));
+        
+        // Set Os if available
+        if let Some(os) = &self.os {
+            worker.set_os(os.clone());
+        }
+        
+        self.workers.lock().unwrap().push(worker.clone());
+        
+        // Publish WorkerEvent::Created
+        self.event_bus.publish(AgentEnvironmentEvent::Worker(
+            WorkerEvent::Created {
+                worker_id: worker.id,
+                name,
+                timestamp: Instant::now(),
+            }
+        ));
+        
+        worker
+    }
+
+    pub fn run_task__agent_loop(
+        &self,
+        worker: Arc<Worker>,
+        input: AgentLoopInput,
+    ) -> Result<Arc<WorkerJob>, eyre::Error> {
+        use super::events::{JobEvent, JobCompletionResult};
+        
+        // Task 3.1.1: Set worker state to Busy
+        self.set_worker_lifecycle_state(worker.id, WorkerLifecycleState::Busy);
+        
+        // Create cancellation token
+        let cancellation_token = CancellationToken::new();
+        
+        // Create task with EventBus
+        let task = AgentLoop::new(
+            worker.clone(),
+            input,
+            self.event_bus.clone(),
+            cancellation_token.clone(),
+        );
+        
+        // Create job
+        let mut job = WorkerJob::new(
+            worker.clone(),
+            Arc::new(task),
+            cancellation_token,
+        );
+        
+        // Task 3.1.2: Publish JobStarted event
+        self.event_bus.publish(AgentEnvironmentEvent::Job(
+            JobEvent::Started {
+                worker_id: worker.id,
+                job_id: Uuid::new_v4(), // TODO: Add job_id to WorkerJob
+                task_type: "AgentLoop".to_string(),
+                timestamp: Instant::now(),
+            }
+        ));
+        
+        // Launch the job
+        job.launch();
+        
+        let job = Arc::new(job);
+        
+        // Register job
+        self.jobs.lock().unwrap().push(job.clone());
+        
+        // Task 3.1.4: Spawn completion handler
+        let session = self.clone();
+        let job_for_completion = job.clone();
+        let worker_id = worker.id;
+        tokio::spawn(async move {
+            // Wait for job to complete by polling
+            while job_for_completion.is_active() {
+                tokio::time::sleep(Duration::from_millis(100)).await;
+            }
+            
+            // Get completion state with error details
+            let continuations_state = job_for_completion.worker_job_continuations.get_state().await;
+            let result = match continuations_state {
+                super::worker_job_continuations::JobState::Running => Ok(()),
+                super::worker_job_continuations::JobState::Done(completion_type, error_msg) => {
+                    match completion_type {
+                        super::worker_job_continuations::WorkerJobCompletionType::Normal => Ok(()),
+                        super::worker_job_continuations::WorkerJobCompletionType::Failed => {
+                            Err(eyre::eyre!(error_msg.unwrap_or_else(|| "Job failed with unknown error".to_string())))
+                        },
+                        super::worker_job_continuations::WorkerJobCompletionType::Cancelled => {
+                            Err(eyre::eyre!("Job cancelled"))
+                        },
+                    }
+                }
+            };
+            
+            // Task 3.1.3: Handle job completion
+            session.handle_job_completion(worker_id, result).await;
+        });
+        
+        Ok(job)
+    }
+    
+    /// Task 3.1.3: Handle job completion
+    async fn handle_job_completion(
+        &self,
+        worker_id: Uuid,
+        result: Result<(), eyre::Error>,
+    ) {
+        use super::events::{JobEvent, JobCompletionResult};
+        
+        // Get worker to extract task metadata
+        let task_metadata = if let Some(worker) = self.get_worker(worker_id) {
+            worker.task_metadata.lock().unwrap().clone()
+        } else {
+            std::collections::HashMap::new()
+        };
+        
+        // Determine completion result
+        let completion_result = match result {
+            Ok(_) => {
+                // Check if task requires user interaction (e.g., tool approval)
+                let user_interaction_required = if let Some(completion_state) = task_metadata.get("agent_loop_completion_state") {
+                    if completion_state.as_str() == Some("completed_with_tool_request") {
+                        UserInteractionRequired::ToolApproval
+                    } else {
+                        UserInteractionRequired::None
+                    }
+                } else {
+                    UserInteractionRequired::None
+                };
+                
+                JobCompletionResult::Success { 
+                    task_metadata,
+                    user_interaction_required,
+                }
+            }
+            Err(e) => {
+                error!(
+                    worker_id = %worker_id,
+                    error = %e,
+                    "Job failed for worker"
+                );
+                JobCompletionResult::Failed {
+                    error: e.to_string(),
+                }
+            }
+        };
+        
+        // Update worker lifecycle state
+        let new_state = match &completion_result {
+            JobCompletionResult::Success { .. } => WorkerLifecycleState::Idle,
+            JobCompletionResult::Failed { .. } => WorkerLifecycleState::IdleFailed,
+            JobCompletionResult::Cancelled => WorkerLifecycleState::Idle,
+        };
+        
+        self.set_worker_lifecycle_state(worker_id, new_state);
+        
+        // Publish completion event
+        self.event_bus.publish(AgentEnvironmentEvent::Job(
+            JobEvent::Completed {
+                worker_id,
+                job_id: Uuid::new_v4(), // TODO: Add job_id to WorkerJob
+                result: completion_result,
+                timestamp: Instant::now(),
+            }
+        ));
+        
+        // Note: Continuations are already run by WorkerJob
+    }
+
+    
+    /// Task 3.1.5: Stub for compact conversation task
+    pub fn run_task__compact_conversation(
+        &self,
+        _worker: Arc<Worker>,
+        _input: super::worker_tasks::CompactInput,
+    ) -> Result<Arc<WorkerJob>, eyre::Error> {
+        // TODO: Implement in Phase 10
+        unimplemented!("run_task__compact_conversation will be implemented in Phase 10")
+    }
+    
+    pub fn cancel_all_jobs(&self) {
+        let jobs = self.jobs.lock().unwrap();
+        for job in jobs.iter() {
+            job.cancel();
+        }
+    }
+
+    /// Cleanup old inactive jobs, keeping only MAX_INACTIVE_JOBS most recent
+    pub fn cleanup_inactive_jobs(&self) {
+        let mut jobs = self.jobs.lock().unwrap();
+        
+        // Separate active and inactive jobs
+        let (active, mut inactive): (Vec<_>, Vec<_>) = jobs
+            .iter()
+            .cloned()
+            .partition(|job| job.is_active());
+        
+        // Keep only last MAX_INACTIVE_JOBS inactive jobs
+        if inactive.len() > MAX_INACTIVE_JOBS {
+            let keep_from = inactive.len() - MAX_INACTIVE_JOBS;
+            inactive.drain(0..keep_from);
+        }
+        
+        // Rebuild jobs list: active + recent inactive
+        *jobs = active;
+        jobs.extend(inactive);
+    }
+
+    /// Get count of active and inactive jobs
+    pub fn get_job_counts(&self) -> (usize, usize) {
+        let jobs = self.jobs.lock().unwrap();
+        let active = jobs.iter().filter(|j| j.is_active()).count();
+        let inactive = jobs.len() - active;
+        (active, inactive)
+    }
+
+    /// Check if there are any active jobs
+    /// 
+    /// Returns true if at least one job is active, false otherwise.
+    /// Note: This checks the active state of jobs, not just if the jobs Vec is non-empty.
+    pub fn has_active_jobs(&self) -> bool {
+        let jobs = self.jobs.lock().unwrap();
+        jobs.iter().any(|job| job.is_active())
+    }
+
+    /// Wait for all active jobs to complete
+    pub async fn wait_for_all_jobs(&self) {
+        loop {
+            let has_active = {
+                let jobs = self.jobs.lock().unwrap();
+                jobs.iter().any(|job| job.is_active())
+            };
+            
+            if !has_active {
+                break;
+            }
+            
+            tokio::time::sleep(Duration::from_millis(50)).await;
+        }
+    }
+    
+    /// Set worker lifecycle state and publish event
+    pub fn set_worker_lifecycle_state(
+        &self,
+        worker_id: Uuid,
+        new_state: WorkerLifecycleState,
+    ) {
+        // Find worker
+        let workers = self.workers.lock().unwrap();
+        if let Some(worker) = workers.iter().find(|w| w.id == worker_id) {
+            // Get old state
+            let old_state = {
+                let state = worker.lifecycle_state.lock().unwrap();
+                *state
+            };
+            
+            // Update state
+            {
+                let mut state = worker.lifecycle_state.lock().unwrap();
+                *state = new_state;
+            }
+            
+            // Publish event
+            self.event_bus.publish(AgentEnvironmentEvent::Worker(
+                WorkerEvent::LifecycleStateChanged {
+                    worker_id,
+                    old_state,
+                    new_state,
+                    timestamp: Instant::now(),
+                }
+            ));
+        }
+    }
+    
+    /// Delete worker and publish event
+    pub fn delete_worker(&self, worker_id: Uuid) -> Result<(), eyre::Error> {
+        // Cancel any active jobs for this worker
+        self.cancel_worker_jobs(worker_id)?;
+        
+        // Remove worker
+        let mut workers = self.workers.lock().unwrap();
+        workers.retain(|w| w.id != worker_id);
+        
+        // Publish event
+        self.event_bus.publish(AgentEnvironmentEvent::Worker(
+            WorkerEvent::Deleted {
+                worker_id,
+                timestamp: Instant::now(),
+            }
+        ));
+        
+        Ok(())
+    }
+    
+    /// Get worker by ID
+    pub fn get_worker(&self, worker_id: Uuid) -> Option<Arc<Worker>> {
+        let workers = self.workers.lock().unwrap();
+        workers.iter().find(|w| w.id == worker_id).cloned()
+    }
+    
+    /// Get all workers
+    pub fn get_workers(&self) -> Vec<Arc<Worker>> {
+        let workers = self.workers.lock().unwrap();
+        workers.clone()
+    }
+    
+    /// Cancel all jobs for a specific worker
+    pub fn cancel_worker_jobs(&self, worker_id: Uuid) -> Result<(), eyre::Error> {
+        let jobs = self.jobs.lock().unwrap();
+        for job in jobs.iter() {
+            if job.worker.id == worker_id {
+                job.cancel();
+            }
+        }
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::agent_env::model_providers::{ModelProvider, ModelRequest, ModelResponse, ModelResponseChunk};
+    use async_trait::async_trait;
+    use eyre::Result;
+    
+    // Mock model provider for testing
+    struct MockModelProvider;
+    
+    #[async_trait]
+    impl ModelProvider for MockModelProvider {
+        async fn request(
+            &self,
+            _request: ModelRequest,
+            _when_receiving_begin: Box<dyn Fn() + Send>,
+            _when_received: Box<dyn Fn(ModelResponseChunk) + Send>,
+            _cancellation_token: CancellationToken,
+        ) -> Result<ModelResponse> {
+            Ok(ModelResponse {
+                content: "mock response".to_string(),
+                tool_requests: vec![],
+            })
+        }
+    }
+    
+    fn create_test_session() -> Session {
+        let event_bus = EventBus::default();
+        let model_providers: Vec<Arc<dyn ModelProvider>> = vec![Arc::new(MockModelProvider)];
+        Session::new(event_bus, model_providers)
+    }
+    
+    #[test]
+    fn test_worker_creation_publishes_event() {
+        let session = create_test_session();
+        let mut receiver = session.event_bus().subscribe();
+        
+        // Create worker
+        let worker = session.build_worker("test_worker".to_string());
+        
+        // Verify event was published
+        let event = receiver.try_recv().expect("Expected WorkerEvent::Created");
+        match event {
+            AgentEnvironmentEvent::Worker(WorkerEvent::Created { worker_id, name, .. }) => {
+                assert_eq!(worker_id, worker.id);
+                assert_eq!(name, "test_worker");
+            }
+            _ => panic!("Expected WorkerEvent::Created"),
+        }
+    }
+    
+    #[test]
+    fn test_worker_deletion_publishes_event() {
+        let session = create_test_session();
+        let worker = session.build_worker("test_worker".to_string());
+        let worker_id = worker.id;
+        
+        // Subscribe after creation to avoid getting Created event
+        let mut receiver = session.event_bus().subscribe();
+        
+        // Delete worker
+        session.delete_worker(worker_id).expect("Failed to delete worker");
+        
+        // Verify event was published
+        let event = receiver.try_recv().expect("Expected WorkerEvent::Deleted");
+        match event {
+            AgentEnvironmentEvent::Worker(WorkerEvent::Deleted { worker_id: deleted_id, .. }) => {
+                assert_eq!(deleted_id, worker_id);
+            }
+            _ => panic!("Expected WorkerEvent::Deleted"),
+        }
+        
+        // Verify worker was removed
+        assert!(session.get_worker(worker_id).is_none());
+    }
+    
+    #[test]
+    fn test_lifecycle_state_transitions() {
+        let session = create_test_session();
+        let worker = session.build_worker("test_worker".to_string());
+        let worker_id = worker.id;
+        
+        // Subscribe after creation
+        let mut receiver = session.event_bus().subscribe();
+        
+        // Transition to Busy
+        session.set_worker_lifecycle_state(worker_id, WorkerLifecycleState::Busy);
+        
+        // Verify event was published
+        let event = receiver.try_recv().expect("Expected LifecycleStateChanged");
+        match event {
+            AgentEnvironmentEvent::Worker(WorkerEvent::LifecycleStateChanged { 
+                worker_id: wid, 
+                old_state, 
+                new_state, 
+                .. 
+            }) => {
+                assert_eq!(wid, worker_id);
+                assert_eq!(old_state, WorkerLifecycleState::Idle);
+                assert_eq!(new_state, WorkerLifecycleState::Busy);
+            }
+            _ => panic!("Expected WorkerEvent::LifecycleStateChanged"),
+        }
+        
+        // Verify state was updated in worker
+        assert_eq!(*worker.lifecycle_state.lock().unwrap(), WorkerLifecycleState::Busy);
+        
+        // Transition to IdleFailed
+        session.set_worker_lifecycle_state(worker_id, WorkerLifecycleState::IdleFailed);
+        
+        let event = receiver.try_recv().expect("Expected LifecycleStateChanged");
+        match event {
+            AgentEnvironmentEvent::Worker(WorkerEvent::LifecycleStateChanged { 
+                old_state, 
+                new_state, 
+                .. 
+            }) => {
+                assert_eq!(old_state, WorkerLifecycleState::Busy);
+                assert_eq!(new_state, WorkerLifecycleState::IdleFailed);
+            }
+            _ => panic!("Expected WorkerEvent::LifecycleStateChanged"),
+        }
+    }
+    
+    #[test]
+    fn test_multiple_workers_dont_interfere() {
+        let session = create_test_session();
+        let mut receiver = session.event_bus().subscribe();
+        
+        // Create two workers
+        let worker1 = session.build_worker("worker1".to_string());
+        let worker2 = session.build_worker("worker2".to_string());
+        
+        // Verify both Created events
+        let event1 = receiver.try_recv().expect("Expected first Created event");
+        let event2 = receiver.try_recv().expect("Expected second Created event");
+        
+        // Verify worker_ids are different
+        let id1 = event1.worker_id().expect("Expected worker_id");
+        let id2 = event2.worker_id().expect("Expected worker_id");
+        assert_ne!(id1, id2);
+        
+        // Change state of worker1
+        session.set_worker_lifecycle_state(worker1.id, WorkerLifecycleState::Busy);
+        
+        // Verify only worker1's state changed
+        assert_eq!(*worker1.lifecycle_state.lock().unwrap(), WorkerLifecycleState::Busy);
+        assert_eq!(*worker2.lifecycle_state.lock().unwrap(), WorkerLifecycleState::Idle);
+    }
+    
+    #[tokio::test]
+    async fn test_job_lifecycle_events() {
+        use crate::agent_env::events::{JobEvent, JobCompletionResult};
+        
+        let session = create_test_session();
+        let worker = session.build_worker("test_worker".to_string());
+        let worker_id = worker.id;
+        
+        // Subscribe after worker creation to avoid Created event
+        let mut receiver = session.event_bus().subscribe();
+        
+        // Launch agent loop task
+        let input = AgentLoopInput {};
+        let _job = session.run_task__agent_loop(worker.clone(), input)
+            .expect("Failed to launch agent loop");
+        
+        // Verify LifecycleStateChanged to Busy
+        let event = receiver.recv().await.expect("Expected LifecycleStateChanged to Busy");
+        match event {
+            AgentEnvironmentEvent::Worker(WorkerEvent::LifecycleStateChanged { 
+                worker_id: wid, 
+                new_state, 
+                .. 
+            }) => {
+                assert_eq!(wid, worker_id);
+                assert_eq!(new_state, WorkerLifecycleState::Busy);
+            }
+            _ => panic!("Expected WorkerEvent::LifecycleStateChanged to Busy, got {:?}", event),
+        }
+        
+        // Verify JobStarted event
+        let event = receiver.recv().await.expect("Expected JobStarted");
+        match event {
+            AgentEnvironmentEvent::Job(JobEvent::Started { 
+                worker_id: wid, 
+                task_type, 
+                .. 
+            }) => {
+                assert_eq!(wid, worker_id);
+                assert_eq!(task_type, "AgentLoop");
+            }
+            _ => panic!("Expected JobEvent::Started, got {:?}", event),
+        }
+        
+        // Wait for job to complete (with timeout)
+        let timeout = tokio::time::sleep(Duration::from_secs(5));
+        tokio::pin!(timeout);
+        
+        let mut got_lifecycle_change = false;
+        let mut got_job_completed = false;
+        
+        loop {
+            tokio::select! {
+                result = receiver.recv() => {
+                    match result {
+                        Ok(event) => {
+                            match event {
+                                AgentEnvironmentEvent::Worker(WorkerEvent::LifecycleStateChanged { 
+                                    worker_id: wid, 
+                                    new_state, 
+                                    .. 
+                                }) if wid == worker_id => {
+                                    // Should transition back to Idle or IdleFailed
+                                    assert!(
+                                        new_state == WorkerLifecycleState::Idle || 
+                                        new_state == WorkerLifecycleState::IdleFailed
+                                    );
+                                    got_lifecycle_change = true;
+                                }
+                                AgentEnvironmentEvent::Job(JobEvent::Completed { 
+                                    worker_id: wid, 
+                                    result, 
+                                    .. 
+                                }) if wid == worker_id => {
+                                    // Verify completion result structure
+                                    match result {
+                                        JobCompletionResult::Success { .. } | 
+                                        JobCompletionResult::Failed { .. } | 
+                                        JobCompletionResult::Cancelled => {
+                                            got_job_completed = true;
+                                        }
+                                    }
+                                }
+                                _ => {} // Ignore other events
+                            }
+                            
+                            if got_lifecycle_change && got_job_completed {
+                                break;
+                            }
+                        }
+                        Err(e) => panic!("Error receiving event: {}", e),
+                    }
+                }
+                _ = &mut timeout => {
+                    panic!("Timeout waiting for job completion events");
+                }
+            }
+        }
+        
+        assert!(got_lifecycle_change, "Did not receive LifecycleStateChanged event");
+        assert!(got_job_completed, "Did not receive JobCompleted event");
+    }
+
+    #[test]
+    fn test_has_active_jobs_no_jobs() {
+        let session = create_test_session();
+        
+        // No jobs exist
+        assert!(!session.has_active_jobs());
+    }
+
+    #[tokio::test]
+    async fn test_has_active_jobs_with_active_job() {
+        let session = create_test_session();
+        let worker = session.build_worker("test_worker".to_string());
+        
+        // Launch a job
+        let input = AgentLoopInput {};
+        let _job = session.run_task__agent_loop(worker.clone(), input)
+            .expect("Failed to launch agent loop");
+        
+        // Should have active jobs
+        assert!(session.has_active_jobs());
+    }
+
+    #[tokio::test]
+    async fn test_has_active_jobs_after_completion() {
+        let session = create_test_session();
+        let worker = session.build_worker("test_worker".to_string());
+        let mut receiver = session.event_bus().subscribe();
+        
+        // Launch a job
+        let input = AgentLoopInput {};
+        let _job = session.run_task__agent_loop(worker.clone(), input)
+            .expect("Failed to launch agent loop");
+        
+        // Wait for job to complete
+        let timeout = tokio::time::sleep(Duration::from_secs(5));
+        tokio::pin!(timeout);
+        
+        loop {
+            tokio::select! {
+                result = receiver.recv() => {
+                    match result {
+                        Ok(AgentEnvironmentEvent::Job(JobEvent::Completed { .. })) => {
+                            break;
+                        }
+                        Ok(_) => {} // Ignore other events
+                        Err(e) => panic!("Error receiving event: {}", e),
+                    }
+                }
+                _ = &mut timeout => {
+                    panic!("Timeout waiting for job completion");
+                }
+            }
+        }
+        
+        // After completion, should have no active jobs
+        assert!(!session.has_active_jobs());
+    }
+}
diff --git a/crates/chat-cli/src/agent_env/worker.rs b/crates/chat-cli/src/agent_env/worker.rs
new file mode 100644
index 000000000..2c7848279
--- /dev/null
+++ b/crates/chat-cli/src/agent_env/worker.rs
@@ -0,0 +1,261 @@
+use std::collections::HashMap;
+use std::sync::{Arc, Mutex};
+use uuid::Uuid;
+use serde::{Serialize, Deserialize};
+
+use super::context_container::ContextContainer;
+use super::model_providers::ModelProvider;
+use super::events::WorkerLifecycleState;
+use crate::os::Os;
+
+#[derive(Debug, Clone, Copy, PartialEq, Default)]
+pub enum WorkerStates {
+    #[default]
+    Inactive,
+    Working,
+    Requesting,
+    Receiving,
+    Waiting,
+    UsingTool,
+    InactiveFailed,
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct Worker {
+    pub id: Uuid,
+    pub name: String,
+    pub context_container: ContextContainer,
+    
+    /// Lifecycle state (managed by Session)
+    #[serde(skip, default = "default_lifecycle_state")]
+    pub lifecycle_state: Arc<Mutex<WorkerLifecycleState>>,
+    
+    /// Task-specific metadata (managed by Tasks)
+    #[serde(skip, default = "default_task_metadata")]
+    pub task_metadata: Arc<Mutex<HashMap<String, serde_json::Value>>>,
+    
+    /// Non-serializable runtime dependencies
+    #[serde(skip, default)]
+    pub model_provider: Option<Arc<dyn ModelProvider>>,
+    
+    #[serde(skip, default = "default_os")]
+    pub os: Arc<Mutex<Option<Arc<Os>>>>,
+    
+    /// Legacy state tracking (to be removed)
+    #[serde(skip, default = "default_worker_state")]
+    pub state: Arc<Mutex<WorkerStates>>,
+    #[serde(skip, default)]
+    pub last_failure: Arc<Mutex<Option<String>>>,
+}
+
+fn default_lifecycle_state() -> Arc<Mutex<WorkerLifecycleState>> {
+    Arc::new(Mutex::new(WorkerLifecycleState::Idle))
+}
+
+fn default_task_metadata() -> Arc<Mutex<HashMap<String, serde_json::Value>>> {
+    Arc::new(Mutex::new(HashMap::new()))
+}
+
+fn default_worker_state() -> Arc<Mutex<WorkerStates>> {
+    Arc::new(Mutex::new(WorkerStates::Inactive))
+}
+
+fn default_os() -> Arc<Mutex<Option<Arc<Os>>>> {
+    Arc::new(Mutex::new(None))
+}
+
+impl Worker {
+    pub fn new(name: String, model_provider: Arc<dyn ModelProvider>) -> Self {
+        Self {
+            id: Uuid::new_v4(),
+            name,
+            context_container: ContextContainer::new(),
+            lifecycle_state: Arc::new(Mutex::new(WorkerLifecycleState::Idle)),
+            task_metadata: Arc::new(Mutex::new(HashMap::new())),
+            model_provider: Some(model_provider),
+            os: Arc::new(Mutex::new(None)),
+            state: Arc::new(Mutex::new(WorkerStates::Inactive)),
+            last_failure: Arc::new(Mutex::new(None)),
+        }
+    }
+    
+    pub fn set_os(&self, os: Arc<Os>) {
+        *self.os.lock().unwrap() = Some(os);
+    }
+    
+    pub fn get_os(&self) -> Option<Arc<Os>> {
+        self.os.lock().unwrap().clone()
+    }
+
+    pub fn set_state(&self, new_state: WorkerStates) {
+        let mut state = self.state.lock().unwrap();
+        *state = new_state;
+    }
+
+    pub fn get_state(&self) -> WorkerStates {
+        *self.state.lock().unwrap()
+    }
+
+    pub fn set_failure(&self, error: String) {
+        let mut failure = self.last_failure.lock().unwrap();
+        *failure = Some(error);
+    }
+
+    pub fn get_failure(&self) -> Option<String> {
+        self.last_failure.lock().unwrap().clone()
+    }
+    
+    /// Set task-specific metadata
+    pub fn set_task_metadata(&self, key: &str, value: serde_json::Value) {
+        self.task_metadata.lock().unwrap().insert(key.to_string(), value);
+    }
+    
+    /// Get task-specific metadata
+    pub fn get_task_metadata(&self, key: &str) -> Option<serde_json::Value> {
+        self.task_metadata.lock().unwrap().get(key).cloned()
+    }
+    
+    /// Get task metadata as string
+    pub fn get_task_metadata_string(&self, key: &str) -> Option<String> {
+        self.task_metadata
+            .lock()
+            .unwrap()
+            .get(key)
+            .and_then(|v| v.as_str())
+            .map(|s| s.to_string())
+    }
+}
+
+/// Namespaced metadata keys to avoid conflicts
+pub mod task_metadata_keys {
+    pub const AGENT_LOOP_COMPLETION_STATE: &str = "agent_loop.completion_state";
+    pub const AGENT_LOOP_LAST_TOOL: &str = "agent_loop.last_tool";
+    pub const COMPACT_LAST_RUN: &str = "compact.last_run_timestamp";
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::agent_env::model_providers::{ModelProvider, ModelRequest, ModelResponse};
+    use async_trait::async_trait;
+    use eyre::Result;
+    use tokio_util::sync::CancellationToken;
+    
+    // Mock model provider for testing
+    struct MockModelProvider;
+    
+    #[async_trait]
+    impl ModelProvider for MockModelProvider {
+        async fn request(
+            &self,
+            _request: ModelRequest,
+            _when_receiving_begin: Box<dyn Fn() + Send>,
+            _when_received: Box<dyn Fn(crate::agent_env::model_providers::ModelResponseChunk) + Send>,
+            _cancellation_token: CancellationToken,
+        ) -> Result<ModelResponse> {
+            Ok(ModelResponse {
+                content: "mock response".to_string(),
+                tool_requests: vec![],
+            })
+        }
+    }
+    
+    fn create_test_worker() -> Worker {
+        let model_provider = Arc::new(MockModelProvider);
+        Worker::new("test_worker".to_string(), model_provider)
+    }
+    
+    #[test]
+    fn test_worker_serialization() {
+        // Create a worker
+        let worker = create_test_worker();
+        
+        // Add some metadata
+        worker.set_task_metadata("test_key", serde_json::json!("test_value"));
+        
+        // Serialize to JSON
+        let json = serde_json::to_string(&worker).expect("Failed to serialize worker");
+        
+        // Verify serialization succeeded
+        assert!(json.contains("test_worker"));
+        
+        // Note: task_metadata is skipped during serialization (Arc<Mutex<>> not serializable)
+        // In real usage, you would serialize/deserialize the metadata separately if needed
+        
+        // Verify skipped fields are not in JSON
+        assert!(!json.contains("model_provider"));
+        assert!(!json.contains("lifecycle_state"));
+        assert!(!json.contains("task_metadata"));
+    }
+    
+    #[test]
+    fn test_worker_deserialization() {
+        // Create JSON with Worker data (minimal fields)
+        let json = r#"{
+            "id": "550e8400-e29b-41d4-a716-446655440000",
+            "name": "test_worker",
+            "context_container": {}
+        }"#;
+        
+        // Deserialize
+        let worker: Worker = serde_json::from_str(json).expect("Failed to deserialize worker");
+        
+        // Verify fields are correctly populated
+        assert_eq!(worker.name, "test_worker");
+        
+        // Verify skipped fields have default values
+        assert_eq!(*worker.lifecycle_state.lock().unwrap(), WorkerLifecycleState::Idle);
+        assert_eq!(*worker.state.lock().unwrap(), WorkerStates::Inactive);
+        
+        // task_metadata should be empty after deserialization
+        assert!(worker.task_metadata.lock().unwrap().is_empty());
+        
+        // model_provider should be None after deserialization
+        assert!(worker.model_provider.is_none());
+        
+        // In real usage, you would set runtime fields manually after deserialization:
+        // worker.model_provider = Some(Arc::new(some_provider));
+        // worker.set_task_metadata("key", value);
+    }
+    
+    #[test]
+    fn test_task_metadata_operations() {
+        let worker = create_test_worker();
+        
+        // Set metadata
+        worker.set_task_metadata("string_key", serde_json::json!("string_value"));
+        worker.set_task_metadata("number_key", serde_json::json!(42));
+        worker.set_task_metadata("bool_key", serde_json::json!(true));
+        
+        // Get metadata
+        assert_eq!(
+            worker.get_task_metadata("string_key"),
+            Some(serde_json::json!("string_value"))
+        );
+        assert_eq!(
+            worker.get_task_metadata("number_key"),
+            Some(serde_json::json!(42))
+        );
+        
+        // Get string metadata
+        assert_eq!(
+            worker.get_task_metadata_string("string_key"),
+            Some("string_value".to_string())
+        );
+        
+        // Non-string metadata returns None for get_task_metadata_string
+        assert_eq!(worker.get_task_metadata_string("number_key"), None);
+        
+        // Non-existent key returns None
+        assert_eq!(worker.get_task_metadata("nonexistent"), None);
+        assert_eq!(worker.get_task_metadata_string("nonexistent"), None);
+    }
+    
+    #[test]
+    fn test_task_metadata_keys_constants() {
+        // Verify constants are defined correctly
+        assert_eq!(task_metadata_keys::AGENT_LOOP_COMPLETION_STATE, "agent_loop.completion_state");
+        assert_eq!(task_metadata_keys::AGENT_LOOP_LAST_TOOL, "agent_loop.last_tool");
+        assert_eq!(task_metadata_keys::COMPACT_LAST_RUN, "compact.last_run_timestamp");
+    }
+}
diff --git a/crates/chat-cli/src/agent_env/worker_builder.rs b/crates/chat-cli/src/agent_env/worker_builder.rs
new file mode 100644
index 000000000..746e0a800
--- /dev/null
+++ b/crates/chat-cli/src/agent_env/worker_builder.rs
@@ -0,0 +1,154 @@
+use std::sync::Arc;
+use std::borrow::Borrow;
+use eyre::Result;
+
+use super::{Session, Worker};
+use crate::cli::Agent;
+use crate::cli::chat::Platform;
+use crate::os::Os;
+
+pub struct WorkerBuilder {
+    agent_name: Option<String>,
+    platform: Platform,
+    model: Option<String>,
+    initial_input: Option<String>,
+}
+
+impl WorkerBuilder {
+    pub fn new() -> Self {
+        Self {
+            agent_name: None,
+            platform: Platform::default(),
+            model: None,
+            initial_input: None,
+        }
+    }
+    
+    pub fn agent(mut self, agent_name: Option<String>) -> Self {
+        self.agent_name = agent_name;
+        self
+    }
+    
+    pub fn platform(mut self, platform: Platform) -> Self {
+        self.platform = platform;
+        self
+    }
+    
+    pub fn model(mut self, model: Option<String>) -> Self {
+        self.model = model;
+        self
+    }
+    
+    pub fn initial_input(mut self, input: Option<String>) -> Self {
+        self.initial_input = input;
+        self
+    }
+    
+    pub async fn build(
+        self,
+        session: Arc<Session>,
+        os: &Os,
+    ) -> Result<Arc<Worker>> {
+        // 1. Load agent config or use default
+        let agent = if let Some(agent_name) = &self.agent_name {
+            let (agent, _path) = Agent::get_agent_by_name(os, agent_name).await?;
+            agent
+        } else {
+            Agent::default()
+        };
+        
+        // 2. Extract resource references (file:// URLs)
+        let resource_refs: Vec<String> = agent.resources
+            .iter()
+            .map(|r| {
+                let s: &str = r.borrow();
+                s.to_string()
+            })
+            .filter(|r| r.starts_with("file://"))
+            .collect();
+        
+        // 3. Create worker through Session (maintains event publishing)
+        let worker = session.build_worker("main".to_string());
+        
+        // 4. Set Os in worker for resource loading
+        worker.set_os(Arc::new(os.clone()));
+        
+        // 5. Populate context container with references only
+        if let Some(prompt) = &agent.prompt {
+            worker.context_container.set_agent_prompt(prompt.clone());
+        }
+        
+        if !resource_refs.is_empty() {
+            worker.context_container.set_resource_references(resource_refs);
+        }
+        
+        // 6. Add initial input if provided
+        if let Some(input) = &self.initial_input {
+            worker.context_container
+                .conversation_history
+                .lock()
+                .unwrap()
+                .push_input_message(input.clone());
+        }
+        
+        Ok(worker)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::agent_env::{EventBus, ModelProvider, ModelRequest, ModelResponse, ModelResponseChunk};
+    use tokio_util::sync::CancellationToken;
+
+    // Mock model provider for testing
+    #[derive(Clone)]
+    struct MockModelProvider;
+
+    #[async_trait::async_trait]
+    impl ModelProvider for MockModelProvider {
+        async fn request(
+            &self,
+            _request: ModelRequest,
+            _when_receiving_begin: Box<dyn Fn() + Send>,
+            _when_received: Box<dyn Fn(ModelResponseChunk) + Send>,
+            _cancellation_token: CancellationToken,
+        ) -> Result<ModelResponse, eyre::Error> {
+            Ok(ModelResponse {
+                content: "test".to_string(),
+                tool_requests: vec![],
+            })
+        }
+    }
+
+    #[tokio::test]
+    async fn test_build_with_default_agent() {
+        let event_bus = EventBus::default();
+        let session = Arc::new(Session::new(event_bus, vec![Arc::new(MockModelProvider)]));
+        let os = Os::new().await.unwrap();
+        
+        let worker = WorkerBuilder::new()
+            .build(session, &os)
+            .await
+            .unwrap();
+        
+        assert!(worker.context_container.get_agent_prompt().is_none());
+        // Default agent has resources, so don't check if empty
+    }
+
+    #[tokio::test]
+    async fn test_build_with_initial_input() {
+        let event_bus = EventBus::default();
+        let session = Arc::new(Session::new(event_bus, vec![Arc::new(MockModelProvider)]));
+        let os = Os::new().await.unwrap();
+        
+        let worker = WorkerBuilder::new()
+            .initial_input(Some("Hello world".to_string()))
+            .build(session, &os)
+            .await
+            .unwrap();
+        
+        let history = worker.context_container.conversation_history.lock().unwrap();
+        assert_eq!(history.len(), 1);
+    }
+}
diff --git a/crates/chat-cli/src/agent_env/worker_job.rs b/crates/chat-cli/src/agent_env/worker_job.rs
new file mode 100644
index 000000000..ec74faad9
--- /dev/null
+++ b/crates/chat-cli/src/agent_env/worker_job.rs
@@ -0,0 +1,99 @@
+use std::sync::Arc;
+use tokio_util::sync::CancellationToken;
+
+use super::worker::Worker;
+use super::worker_task::WorkerTask;
+use super::worker_job_continuations::{Continuations, WorkerJobCompletionType};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum JobState {
+    Active,
+    Completed,
+    Cancelled,
+    Failed,
+}
+
+pub struct WorkerJob {
+    pub worker: Arc<Worker>,
+    pub worker_task: Arc<dyn WorkerTask>,
+    pub cancellation_token: CancellationToken,
+    pub task_handle: Option<tokio::task::JoinHandle<Result<(), eyre::Error>>>,
+    pub worker_job_continuations: Arc<Continuations>,
+}
+
+impl WorkerJob {
+    pub fn new(
+        worker: Arc<Worker>,
+        worker_task: Arc<dyn WorkerTask>,
+        cancellation_token: CancellationToken,
+    ) -> Self {
+        Self {
+            worker,
+            worker_task,
+            cancellation_token,
+            task_handle: None,
+            worker_job_continuations: Arc::new(Continuations::new()),
+        }
+    }
+
+    pub fn launch(&mut self) {
+        let worker_task_clone = self.worker_task.clone();
+        let continuations = Arc::clone(&self.worker_job_continuations);
+        let worker = Arc::clone(&self.worker);
+        let cancellation_token = self.cancellation_token.clone();
+        
+        let task_handle = tokio::spawn(async move {
+            let result = worker_task_clone.run().await;
+            continuations.complete(result, worker, &cancellation_token).await;
+            Ok(())
+        });
+        self.task_handle = Some(task_handle);
+    }
+
+    pub fn cancel(&self) {
+        self.cancellation_token.cancel();
+    }
+
+    pub async fn wait(self) -> Result<(), eyre::Error> {
+        match self.task_handle {
+            Some(handle) => match handle.await {
+                Ok(result) => result,
+                Err(join_error) => Err(eyre::eyre!("Task panicked: {}", join_error)),
+            },
+            None => Err(eyre::eyre!("Task not launched")),
+        }
+    }
+
+    /// Check if job is still active (running)
+    pub fn is_active(&self) -> bool {
+        match &self.task_handle {
+            Some(handle) => !handle.is_finished(),
+            None => false,
+        }
+    }
+
+    /// Check if job is complete (finished, cancelled, or failed)
+    pub fn is_complete(&self) -> bool {
+        !self.is_active()
+    }
+
+    /// Get current job state
+    pub async fn get_state(&self) -> JobState {
+        if self.is_active() {
+            return JobState::Active;
+        }
+
+        // Job is complete, check completion type from continuations
+        let state = self.worker_job_continuations.get_state().await;
+        match state {
+            super::worker_job_continuations::JobState::Running => JobState::Active,
+            super::worker_job_continuations::JobState::Done(completion_type, _) => {
+                match completion_type {
+                    WorkerJobCompletionType::Normal => JobState::Completed,
+                    WorkerJobCompletionType::Cancelled => JobState::Cancelled,
+                    WorkerJobCompletionType::Failed => JobState::Failed,
+                }
+            }
+        }
+    }
+}
diff --git a/crates/chat-cli/src/agent_env/worker_job_continuations.rs b/crates/chat-cli/src/agent_env/worker_job_continuations.rs
new file mode 100644
index 000000000..76f7e4809
--- /dev/null
+++ b/crates/chat-cli/src/agent_env/worker_job_continuations.rs
@@ -0,0 +1,92 @@
+use std::collections::HashMap;
+use std::pin::Pin;
+use std::future::Future;
+use std::sync::Arc;
+use tokio::sync::RwLock;
+use tokio_util::sync::CancellationToken;
+
+use super::worker::Worker;
+
+#[derive(Debug, Clone, Copy)]
+pub enum WorkerJobCompletionType {
+    Normal,
+    Cancelled,
+    Failed,
+}
+
+#[derive(Clone, Debug)]
+pub enum JobState {
+    Running,
+    Done(WorkerJobCompletionType, Option<String>),
+}
+
+pub type WorkerJobContinuationFn = Arc<
+    dyn Fn(Arc<Worker>, WorkerJobCompletionType, Option<String>) -> Pin<Box<dyn Future<Output = ()> + Send>>
+        + Send + Sync,
+>;
+
+pub struct Continuations {
+    pub(crate) state: RwLock<JobState>,
+    map: RwLock<HashMap<String, WorkerJobContinuationFn>>,
+}
+
+impl Continuations {
+    pub fn new() -> Self {
+        Self {
+            state: RwLock::new(JobState::Running),
+            map: RwLock::new(HashMap::new()),
+        }
+    }
+    
+    /// Get current job state
+    pub async fn get_state(&self) -> JobState {
+        self.state.read().await.clone()
+    }
+
+    pub fn boxed<F, Fut>(f: F) -> WorkerJobContinuationFn
+    where
+        F: Fn(Arc<Worker>, WorkerJobCompletionType, Option<String>) -> Fut + Send + Sync + 'static,
+        Fut: Future<Output = ()> + Send + 'static,
+    {
+        Arc::new(move |worker, completion_type, error_msg| Box::pin(f(worker, completion_type, error_msg)))
+    }
+
+    pub async fn add_or_run_now(&self, key: impl Into<String>, callback: WorkerJobContinuationFn, worker: Arc<Worker>) {
+        match &*self.state.read().await {
+            JobState::Running => {
+                self.map.write().await.insert(key.into(), callback);
+            }
+            JobState::Done(completion_type, error_msg) => {
+                let completion_type = *completion_type;
+                let error_msg = error_msg.clone();
+                tokio::spawn(callback(worker, completion_type, error_msg));
+            }
+        }
+    }
+
+    pub async fn complete(&self, result: Result<(), eyre::Error>, worker: Arc<Worker>, cancellation_token: &CancellationToken) {
+        let completion_type = if cancellation_token.is_cancelled() {
+            WorkerJobCompletionType::Cancelled
+        } else if result.is_err() {
+            WorkerJobCompletionType::Failed
+        } else {
+            WorkerJobCompletionType::Normal
+        };
+
+        let error_msg = result.err().map(|e| e.to_string());
+
+        {
+            let mut st = self.state.write().await;
+            *st = JobState::Done(completion_type, error_msg.clone());
+        }
+        let callbacks = {
+            let mut map = self.map.write().await;
+            std::mem::take(&mut *map)
+        };
+        for (_name, cb) in callbacks {
+            let worker_clone = Arc::clone(&worker);
+            let error_msg_clone = error_msg.clone();
+            tokio::spawn(cb(worker_clone, completion_type, error_msg_clone));
+        }
+    }
+}
diff --git a/crates/chat-cli/src/agent_env/worker_task.rs b/crates/chat-cli/src/agent_env/worker_task.rs
new file mode 100644
index 000000000..37ef20803
--- /dev/null
+++ b/crates/chat-cli/src/agent_env/worker_task.rs
@@ -0,0 +1,7 @@
+use super::worker::Worker;
+
+#[async_trait::async_trait]
+pub trait WorkerTask: Send + Sync {
+    fn get_worker(&self) -> &Worker;
+    async fn run(&self) -> Result<(), eyre::Error>;
+}
diff --git a/crates/chat-cli/src/agent_env/worker_tasks/agent_loop.rs b/crates/chat-cli/src/agent_env/worker_tasks/agent_loop.rs
new file mode 100644
index 000000000..2574df00a
--- /dev/null
+++ b/crates/chat-cli/src/agent_env/worker_tasks/agent_loop.rs
@@ -0,0 +1,517 @@
+use std::sync::Arc;
+use std::time::Instant;
+use tokio_util::sync::CancellationToken;
+use tracing::{info, debug, error};
+
+use crate::agent_env::{
+    Worker, WorkerTask, WorkerStates,
+    ModelRequest, ModelResponse,
+    EventBus, AgentEnvironmentEvent, JobEvent, AgentLoopEvent, OutputChunk,
+};
+use crate::agent_env::worker::task_metadata_keys;
+use crate::cli::chat::message::AssistantMessage;
+
+pub struct AgentLoopInput {
+    // Empty - all context comes from Worker
+}
+
+pub struct AgentLoop {
+    worker: Arc<Worker>,
+    event_bus: EventBus,
+    cancellation_token: CancellationToken,
+}
+
+impl AgentLoop {
+    pub fn new(
+        worker: Arc<Worker>,
+        _input: AgentLoopInput,
+        event_bus: EventBus,
+        cancellation_token: CancellationToken,
+    ) -> Self {
+        Self {
+            worker,
+            event_bus,
+            cancellation_token,
+        }
+    }
+
+    fn check_cancellation(&self) -> Result<(), eyre::Error> {
+        if self.cancellation_token.is_cancelled() {
+            debug!(worker_id = %self.worker.id, "Cancelled");
+            Err(eyre::eyre!("Cancelled"))
+        } else {
+            Ok(())
+        }
+    }
+
+    async fn query_llm(&self) -> Result<ModelResponse, eyre::Error> {
+        self.check_cancellation()?;
+        
+        // Get Os from worker
+        let os = self.worker.get_os()
+            .ok_or_else(|| eyre::eyre!("Os not available in worker"))?;
+        
+        // Build request using ContextBuilder
+        let request = crate::agent_env::ContextBuilder::build_request(
+            &self.worker.context_container,
+            &os
+        ).await?;
+
+        self.worker.set_state(WorkerStates::Requesting);
+        
+        let worker = self.worker.clone();
+        let worker_id = self.worker.id;
+        let event_bus = self.event_bus.clone();
+        let job_id = uuid::Uuid::new_v4();
+        
+        let model_provider = self.worker.model_provider.as_ref()
+            .ok_or_else(|| eyre::eyre!("model_provider not available"))?;
+        
+        let response = model_provider.request(
+            request,
+            Box::new(move || {
+                worker.set_state(WorkerStates::Receiving);
+            }),
+            Box::new(move |chunk| {
+                use crate::agent_env::model_providers::ModelResponseChunk;
+                if let ModelResponseChunk::AssistantMessage(text) = chunk {
+                    event_bus.publish(AgentEnvironmentEvent::Job(
+                        JobEvent::OutputChunk {
+                            worker_id,
+                            job_id,
+                            chunk: OutputChunk::AssistantResponse(text),
+                            timestamp: Instant::now(),
+                        }
+                    ));
+                }
+            }),
+            self.cancellation_token.clone(),
+        ).await.map_err(|e| {
+            if !self.cancellation_token.is_cancelled() {
+                let error_msg = format!("LLM request failed: {}", e);
+                error!(worker_id = %self.worker.id, error = %e, "LLM request failed");
+                self.worker.set_failure(error_msg);
+                self.worker.set_state(WorkerStates::InactiveFailed);
+            } else {
+                self.worker.set_state(WorkerStates::Inactive);
+            }
+            e
+        })?;
+
+        debug!(
+            worker_id = %self.worker.id,
+            content_len = response.content.len(),
+            tool_count = response.tool_requests.len(),
+            "LLM response received"
+        );
+
+        Ok(response)
+    }
+}
+
+#[async_trait::async_trait]
+impl WorkerTask for AgentLoop {
+    fn get_worker(&self) -> &Worker {
+        &self.worker
+    }
+
+    async fn run(&self) -> Result<(), eyre::Error> {
+        let start = Instant::now();
+        let job_id = uuid::Uuid::new_v4(); // TODO: Get from WorkerJob
+        info!(worker_id = %self.worker.id, "Agent loop started");
+
+        self.check_cancellation()?;
+        self.worker.set_failure("".to_string());
+        self.worker.set_state(WorkerStates::Working);
+
+        let response = self.query_llm().await?;
+
+        // Publish events for tool use requests FIRST
+        for tool_request in &response.tool_requests {
+            // Parse parameters as JSON
+            let tool_input: serde_json::Value = serde_json::from_str(&tool_request.parameters)
+                .unwrap_or_else(|_| serde_json::Value::String(tool_request.parameters.clone()));
+
+            // Publish OutputChunk event for tool use
+            self.event_bus.publish(AgentEnvironmentEvent::Job(
+                JobEvent::OutputChunk {
+                    worker_id: self.worker.id,
+                    job_id,
+                    chunk: OutputChunk::ToolUse {
+                        tool_name: tool_request.tool_name.clone(),
+                        tool_input: tool_input.clone(),
+                    },
+                    timestamp: Instant::now(),
+                }
+            ));
+
+            // Publish AgentLoopEvent for tool use request
+            self.event_bus.publish(AgentEnvironmentEvent::AgentLoop(
+                AgentLoopEvent::ToolUseRequestReceived {
+                    worker_id: self.worker.id,
+                    job_id,
+                    tool_name: tool_request.tool_name.clone(),
+                    tool_input,
+                    timestamp: Instant::now(),
+                }
+            ));
+        }
+
+        // Publish AgentLoopEvent for complete response AFTER tool events
+        self.event_bus.publish(AgentEnvironmentEvent::AgentLoop(
+            AgentLoopEvent::ResponseReceived {
+                worker_id: self.worker.id,
+                job_id,
+                text: response.content.clone(),
+                timestamp: Instant::now(),
+            }
+        ));
+
+        // Create assistant message and add to history
+        let assistant_message = if response.tool_requests.is_empty() {
+            AssistantMessage::new_response(None, response.content.clone())
+        } else {
+            // For now, create a simple response. Tool support will be added later.
+            AssistantMessage::new_response(None, response.content.clone())
+        };
+
+        self.worker.context_container
+            .conversation_history
+            .lock()
+            .unwrap()
+            .push_assistant_message(assistant_message);
+
+        // Set completion state metadata
+        if !response.tool_requests.is_empty() {
+            // Tool approval needed (for future implementation)
+            self.worker.set_task_metadata(
+                task_metadata_keys::AGENT_LOOP_COMPLETION_STATE,
+                serde_json::Value::String("completed_with_tool_request".to_string()),
+            );
+            info!(
+                worker_id = %self.worker.id,
+                tool_count = response.tool_requests.len(),
+                "Tool requests accumulated - approval needed"
+            );
+        } else {
+            // Normal completion - ready for new prompt
+            self.worker.set_task_metadata(
+                task_metadata_keys::AGENT_LOOP_COMPLETION_STATE,
+                serde_json::Value::String("completed_ready_for_prompt".to_string()),
+            );
+        }
+
+        self.worker.set_state(WorkerStates::Inactive);
+        
+        let elapsed = start.elapsed();
+        info!(
+            worker_id = %self.worker.id,
+            duration_ms = elapsed.as_millis(),
+            "Agent loop completed"
+        );
+
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::agent_env::{
+        EventBus, Session, ModelProvider, ModelRequest, ModelResponse,
+        model_providers::{ModelResponseChunk, ToolRequest},
+    };
+    use crate::cli::chat::message::{UserMessage, UserMessageContent};
+    use async_trait::async_trait;
+    use std::sync::Arc;
+    use tokio::sync::Mutex as TokioMutex;
+
+    /// Mock model provider for testing
+    struct MockModelProvider {
+        response: Arc<TokioMutex<Option<ModelResponse>>>,
+    }
+
+    impl MockModelProvider {
+        fn new(response: ModelResponse) -> Self {
+            Self {
+                response: Arc::new(TokioMutex::new(Some(response))),
+            }
+        }
+    }
+
+    #[async_trait]
+    impl ModelProvider for MockModelProvider {
+        async fn request(
+            &self,
+            _request: ModelRequest,
+            on_start: Box<dyn Fn() + Send>,
+            on_chunk: Box<dyn Fn(ModelResponseChunk) + Send>,
+            _cancellation_token: CancellationToken,
+        ) -> Result<ModelResponse, eyre::Error> {
+            on_start();
+            
+            let response = self.response.lock().await.take()
+                .ok_or_else(|| eyre::eyre!("Response already consumed"))?;
+            
+            // Simulate streaming chunks
+            for chunk in response.content.chars().collect::<Vec<_>>().chunks(10) {
+                let chunk_str: String = chunk.iter().collect();
+                on_chunk(ModelResponseChunk::AssistantMessage(chunk_str));
+            }
+            
+            Ok(response)
+        }
+    }
+
+    #[tokio::test]
+    async fn test_agent_loop_publishes_output_chunk_events() {
+        // Create EventBus and Session
+        let event_bus = EventBus::default();
+        let mock_provider = Arc::new(MockModelProvider::new(ModelResponse {
+            content: "Hello, this is a test response!".to_string(),
+            tool_requests: vec![],
+        }));
+        let session = Arc::new(Session::new(event_bus.clone(), vec![mock_provider]));
+        
+        // Create worker and add initial message
+        let worker = session.build_worker("test".to_string());
+        let os = crate::os::Os::new().await.unwrap();
+        worker.set_os(Arc::new(os));
+        worker.context_container
+            .conversation_history
+            .lock()
+            .unwrap()
+            .push_input_message("Test prompt".to_string());
+        
+        // Subscribe to events
+        let mut receiver = event_bus.subscribe();
+        
+        // Create and run AgentLoop
+        let agent_loop = AgentLoop::new(
+            worker.clone(),
+            AgentLoopInput {},
+            event_bus.clone(),
+            CancellationToken::new(),
+        );
+        
+        // Run agent loop in background
+        let worker_id = worker.id;
+        tokio::spawn(async move {
+            let _ = agent_loop.run().await;
+        });
+        
+        // Collect events
+        let mut output_chunks = Vec::new();
+        let mut response_received = false;
+        
+        // Wait for events with timeout
+        let timeout = tokio::time::Duration::from_secs(5);
+        let start = tokio::time::Instant::now();
+        
+        while start.elapsed() < timeout {
+            match tokio::time::timeout(
+                tokio::time::Duration::from_millis(100),
+                receiver.recv()
+            ).await {
+                Ok(Ok(event)) => {
+                    if let Some(wid) = event.worker_id() {
+                        if wid == worker_id {
+                            match event {
+                                AgentEnvironmentEvent::Job(JobEvent::OutputChunk { chunk, .. }) => {
+                                    if let OutputChunk::AssistantResponse(text) = chunk {
+                                        output_chunks.push(text);
+                                    }
+                                }
+                                AgentEnvironmentEvent::AgentLoop(AgentLoopEvent::ResponseReceived { .. }) => {
+                                    response_received = true;
+                                    break;
+                                }
+                                _ => {}
+                            }
+                        }
+                    }
+                }
+                Ok(Err(_)) => break,
+                Err(_) => continue,
+            }
+        }
+        
+        // Verify events were published
+        assert!(!output_chunks.is_empty(), "Should have received output chunks");
+        assert!(response_received, "Should have received ResponseReceived event");
+        
+        // Verify chunks combine to full response
+        let combined: String = output_chunks.join("");
+        assert!(combined.contains("Hello"), "Combined chunks should contain response text");
+    }
+
+    #[tokio::test]
+    async fn test_agent_loop_publishes_tool_use_events() {
+        // Create EventBus and Session with tool use response
+        let event_bus = EventBus::default();
+        let mock_provider = Arc::new(MockModelProvider::new(ModelResponse {
+            content: "I'll use a tool to help.".to_string(),
+            tool_requests: vec![
+                ToolRequest {
+                    tool_name: "test_tool".to_string(),
+                    parameters: r#"{"arg": "value"}"#.to_string(),
+                },
+            ],
+        }));
+        let session = Arc::new(Session::new(event_bus.clone(), vec![mock_provider]));
+        
+        // Create worker and add initial message
+        let worker = session.build_worker("test".to_string());
+        let os = crate::os::Os::new().await.unwrap();
+        worker.set_os(Arc::new(os));
+        worker.context_container
+            .conversation_history
+            .lock()
+            .unwrap()
+            .push_input_message("Test prompt".to_string());
+        
+        // Subscribe to events
+        let mut receiver = event_bus.subscribe();
+        
+        // Create and run AgentLoop
+        let agent_loop = AgentLoop::new(
+            worker.clone(),
+            AgentLoopInput {},
+            event_bus.clone(),
+            CancellationToken::new(),
+        );
+        
+        // Run agent loop in background
+        let worker_id = worker.id;
+        tokio::spawn(async move {
+            let _ = agent_loop.run().await;
+        });
+        
+        // Collect events
+        let mut tool_use_chunks = Vec::new();
+        let mut tool_use_requests = Vec::new();
+        
+        // Wait for events with timeout
+        let timeout = tokio::time::Duration::from_secs(5);
+        let start = tokio::time::Instant::now();
+        
+        while start.elapsed() < timeout {
+            match tokio::time::timeout(
+                tokio::time::Duration::from_millis(100),
+                receiver.recv()
+            ).await {
+                Ok(Ok(event)) => {
+                    if let Some(wid) = event.worker_id() {
+                        if wid == worker_id {
+                            match event {
+                                AgentEnvironmentEvent::Job(JobEvent::OutputChunk { chunk, .. }) => {
+                                    if let OutputChunk::ToolUse { tool_name, .. } = chunk {
+                                        tool_use_chunks.push(tool_name);
+                                    }
+                                }
+                                AgentEnvironmentEvent::AgentLoop(AgentLoopEvent::ToolUseRequestReceived { tool_name, .. }) => {
+                                    tool_use_requests.push(tool_name);
+                                }
+                                AgentEnvironmentEvent::AgentLoop(AgentLoopEvent::ResponseReceived { .. }) => {
+                                    break;
+                                }
+                                _ => {}
+                            }
+                        }
+                    }
+                }
+                Ok(Err(_)) => break,
+                Err(_) => continue,
+            }
+        }
+        
+        // Verify tool use events were published
+        assert_eq!(tool_use_chunks.len(), 1, "Should have received 1 ToolUse OutputChunk");
+        assert_eq!(tool_use_requests.len(), 1, "Should have received 1 ToolUseRequestReceived event");
+        assert_eq!(tool_use_chunks[0], "test_tool");
+        assert_eq!(tool_use_requests[0], "test_tool");
+    }
+
+    #[tokio::test]
+    async fn test_agent_loop_sets_completion_state_metadata() {
+        // Test with normal completion (no tools)
+        let event_bus = EventBus::default();
+        let mock_provider = Arc::new(MockModelProvider::new(ModelResponse {
+            content: "Simple response".to_string(),
+            tool_requests: vec![],
+        }));
+        let session = Arc::new(Session::new(event_bus.clone(), vec![mock_provider]));
+        
+        let worker = session.build_worker("test".to_string());
+        let os = crate::os::Os::new().await.unwrap();
+        worker.set_os(Arc::new(os));
+        worker.context_container
+            .conversation_history
+            .lock()
+            .unwrap()
+            .push_input_message("Test prompt".to_string());
+        
+        let agent_loop = AgentLoop::new(
+            worker.clone(),
+            AgentLoopInput {},
+            event_bus.clone(),
+            CancellationToken::new(),
+        );
+        
+        // Run agent loop
+        agent_loop.run().await.expect("Agent loop should complete");
+        
+        // Check completion state metadata
+        let completion_state = worker.get_task_metadata_string(
+            task_metadata_keys::AGENT_LOOP_COMPLETION_STATE
+        );
+        assert_eq!(
+            completion_state,
+            Some("completed_ready_for_prompt".to_string()),
+            "Should set completion state to ready_for_prompt"
+        );
+        
+        // Test with tool request
+        let event_bus2 = EventBus::default();
+        let mock_provider2 = Arc::new(MockModelProvider::new(ModelResponse {
+            content: "Using tool".to_string(),
+            tool_requests: vec![
+                ToolRequest {
+                    tool_name: "test_tool".to_string(),
+                    parameters: "{}".to_string(),
+                },
+            ],
+        }));
+        let session2 = Arc::new(Session::new(event_bus2.clone(), vec![mock_provider2]));
+        
+        let worker2 = session2.build_worker("test2".to_string());
+        let os2 = crate::os::Os::new().await.unwrap();
+        worker2.set_os(Arc::new(os2));
+        worker2.context_container
+            .conversation_history
+            .lock()
+            .unwrap()
+            .push_input_message("Test prompt".to_string());
+        
+        let agent_loop2 = AgentLoop::new(
+            worker2.clone(),
+            AgentLoopInput {},
+            event_bus2.clone(),
+            CancellationToken::new(),
+        );
+        
+        // Run agent loop
+        agent_loop2.run().await.expect("Agent loop should complete");
+        
+        // Check completion state metadata
+        let completion_state2 = worker2.get_task_metadata_string(
+            task_metadata_keys::AGENT_LOOP_COMPLETION_STATE
+        );
+        assert_eq!(
+            completion_state2,
+            Some("completed_with_tool_request".to_string()),
+            "Should set completion state to with_tool_request"
+        );
+    }
+}
+
diff --git a/crates/chat-cli/src/agent_env/worker_tasks/mod.rs b/crates/chat-cli/src/agent_env/worker_tasks/mod.rs
new file mode 100644
index 000000000..9f5a6caf1
--- /dev/null
+++ b/crates/chat-cli/src/agent_env/worker_tasks/mod.rs
@@ -0,0 +1,9 @@
+pub mod agent_loop;
+
+pub use agent_loop::{AgentLoop, AgentLoopInput};
+
+// Stub for Phase 10
+#[derive(Debug, Clone)]
+pub struct CompactInput {
+    pub instruction: Option<String>,
+}
diff --git a/crates/chat-cli/src/api_client/mod.rs b/crates/chat-cli/src/api_client/mod.rs
index f21b448b7..4774cf05a 100644
--- a/crates/chat-cli/src/api_client/mod.rs
+++ b/crates/chat-cli/src/api_client/mod.rs
@@ -582,6 +582,11 @@ impl ApiClient {
         }
     }
 
+    /// Get the CodeWhisperer streaming client (bearer token auth)
+    pub fn streaming_client(&self) -> Option<CodewhispererStreamingClient> {
+        self.streaming_client.clone()
+    }
+
     /// Only meant for testing. Do not use outside of testing responses.
     pub fn set_mock_output(&mut self, json: serde_json::Value) {
         let mut mock = Vec::new();
diff --git a/crates/chat-cli/src/cli/chat/agent_env_ui/ctrl_c_handler.rs b/crates/chat-cli/src/cli/chat/agent_env_ui/ctrl_c_handler.rs
new file mode 100644
index 000000000..e6d4838f4
--- /dev/null
+++ b/crates/chat-cli/src/cli/chat/agent_env_ui/ctrl_c_handler.rs
@@ -0,0 +1,60 @@
+use std::sync::Arc;
+use std::sync::atomic::{AtomicU64, Ordering};
+use tokio::signal;
+use tokio::sync::Notify;
+
+use crate::agent_env::Session;
+
+pub struct CtrlCHandler {
+    last_interrupt_time: Arc<AtomicU64>,
+    shutdown_signal: Arc<Notify>,
+    session: Arc<Session>,
+}
+
+impl CtrlCHandler {
+    pub fn new(shutdown_signal: Arc<Notify>, session: Arc<Session>) -> Self {
+        Self {
+            last_interrupt_time: Arc::new(AtomicU64::new(0)),
+            shutdown_signal,
+            session,
+        }
+    }
+    
+    /// Start listening for Ctrl+C signals
+    pub fn start_listening(self: Arc<Self>) {
+        tokio::spawn(async move {
+            loop {
+                match signal::ctrl_c().await {
+                    Ok(()) => {
+                        self.handle_ctrl_c().await;
+                    }
+                    Err(e) => {
+                        eprintln!("Error setting up Ctrl+C handler: {}", e);
+                        break;
+                    }
+                }
+            }
+        });
+    }
+    
+    /// Handle Ctrl+C signal
+    async fn handle_ctrl_c(&self) {
+        let now = std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .unwrap()
+            .as_millis() as u64;
+        
+        let last_time = self.last_interrupt_time.swap(now, Ordering::SeqCst);
+        let time_since_last = now.saturating_sub(last_time);
+        
+        if time_since_last < 1000 {
+            // Double Ctrl+C (within 1 second) - force exit
+            println!("\n^C (Force exit)");
+            self.shutdown_signal.notify_one();
+        } else {
+            // First Ctrl+C - cancel all active jobs
+            println!("\n^C (Cancelling... Press Ctrl+C again to force exit)");
+            self.session.cancel_all_jobs();
+        }
+    }
+}
diff --git a/crates/chat-cli/src/cli/chat/agent_env_ui/input_handler.rs b/crates/chat-cli/src/cli/chat/agent_env_ui/input_handler.rs
new file mode 100644
index 000000000..653d31289
--- /dev/null
+++ b/crates/chat-cli/src/cli/chat/agent_env_ui/input_handler.rs
@@ -0,0 +1,65 @@
+use rustyline::{Editor, history::FileHistory};
+use std::path::PathBuf;
+
+pub struct InputHandler {
+    editor: Editor<(), FileHistory>,
+    history_path: Option<PathBuf>,
+}
+
+impl InputHandler {
+    pub fn new(history_path: Option<PathBuf>) -> Result<Self, eyre::Error> {
+        let mut editor = Editor::<(), FileHistory>::new()?;
+        
+        if let Some(path) = &history_path {
+            let _ = editor.load_history(path);
+        }
+        
+        Ok(Self {
+            editor,
+            history_path,
+        })
+    }
+    
+    /// Read one line of input (blocking)
+    /// Returns Err on Ctrl+C or Ctrl+D
+    pub async fn read_line(&mut self, worker_name: &str) -> Result<String, eyre::Error> {
+        // Ensure we're on a new line before showing prompt
+        println!();
+        
+        let prompt = format!("{}> ", worker_name);
+        
+        // Run in blocking task since rustyline is not async
+        let mut editor = std::mem::replace(&mut self.editor, Editor::new()?);
+        let result = tokio::task::spawn_blocking(move || {
+            let res = editor.readline(&prompt);
+            (editor, res)
+        }).await?;
+        
+        self.editor = result.0;
+        
+        match result.1 {
+            Ok(line) => {
+                if !line.trim().is_empty() {
+                    self.editor.add_history_entry(&line)?;
+                }
+                Ok(line)
+            }
+            Err(rustyline::error::ReadlineError::Interrupted) => {
+                Err(eyre::eyre!("User interrupted (Ctrl+C)"))
+            }
+            Err(rustyline::error::ReadlineError::Eof) => {
+                Err(eyre::eyre!("User interrupted (Ctrl+D)"))
+            }
+            Err(e) => {
+                Err(eyre::eyre!("Input error: {}", e))
+            }
+        }
+    }
+    
+    pub fn save_history(&mut self) -> Result<(), eyre::Error> {
+        if let Some(path) = &self.history_path {
+            self.editor.save_history(path)?;
+        }
+        Ok(())
+    }
+}
diff --git a/crates/chat-cli/src/cli/chat/agent_env_ui/mod.rs b/crates/chat-cli/src/cli/chat/agent_env_ui/mod.rs
new file mode 100644
index 000000000..5976d8db9
--- /dev/null
+++ b/crates/chat-cli/src/cli/chat/agent_env_ui/mod.rs
@@ -0,0 +1,16 @@
+// Reusable UI components
+pub mod input_handler;
+pub mod ctrl_c_handler;
+pub mod ui_utils;
+
+// UI implementations
+pub mod text_ui;
+pub mod structured_io;
+
+// Re-exports
+pub use input_handler::InputHandler;
+pub use ctrl_c_handler::CtrlCHandler;
+pub use ui_utils::{TokenUsage, calculate_token_usage, format_context_info};
+pub use text_ui::TextUi;
+pub use structured_io::StructuredIO;
+
diff --git a/crates/chat-cli/src/cli/chat/agent_env_ui/structured_io.rs b/crates/chat-cli/src/cli/chat/agent_env_ui/structured_io.rs
new file mode 100644
index 000000000..1f50ee4b0
--- /dev/null
+++ b/crates/chat-cli/src/cli/chat/agent_env_ui/structured_io.rs
@@ -0,0 +1,618 @@
+use crate::agent_env::{
+    AgentEnvironmentCommand, AgentEnvironmentEvent, AgentLoopEvent, JobCompletionResult, JobEvent,
+    PromptResult, Session, UserInterface, WorkerEvent, WorkerLifecycleState,
+};
+use async_trait::async_trait;
+use eyre::Result;
+use owo_colors::OwoColorize;
+use serde_json::json;
+use std::io::Write;
+use std::sync::Arc;
+use tokio::io::{AsyncBufReadExt, BufReader};
+use tokio::sync::{mpsc, Mutex as TokioMutex, Notify};
+use tokio::task::JoinHandle;
+use uuid::Uuid;
+
+/// StructuredIO UI implementation
+///
+/// Reads single-line prompts from stdin and outputs structured JSON events.
+/// Suitable for scripting and automation where commands may be piped in.
+pub struct StructuredIO {
+    session: Arc<Session>,
+    cmd_sender: mpsc::Sender<PromptResult>,
+    cmd_receiver: Arc<TokioMutex<Option<mpsc::Receiver<PromptResult>>>>,
+    output_writer: Arc<TokioMutex<Box<dyn Write + Send>>>,
+    interactive: bool,
+    shutdown_signal: Arc<Notify>,
+}
+
+impl StructuredIO {
+    /// Create new StructuredIO instance
+    ///
+    /// Returns tuple of (StructuredIO, Receiver) following Option C pattern from design.
+    /// The receiver should be passed to AgentEnvironment.
+    pub fn new(session: Arc<Session>, interactive: bool) -> Result<Self> {
+        let (cmd_sender, cmd_receiver) = mpsc::channel(10);
+
+        Ok(Self {
+            session,
+            cmd_sender,
+            cmd_receiver: Arc::new(TokioMutex::new(Some(cmd_receiver))),
+            output_writer: Arc::new(TokioMutex::new(Box::new(std::io::stdout()))),
+            interactive,
+            shutdown_signal: Arc::new(Notify::new()),
+        })
+    }
+
+    /// Spawn input reader task with reader task pattern for responsive quit
+    fn spawn_input_reader(&self) -> JoinHandle<()> {
+        let cmd_sender = self.cmd_sender.clone();
+        let session = self.session.clone();
+        let shutdown = self.shutdown_signal.clone();
+
+        tokio::spawn(async move {
+            tracing::info!("StructuredIO input reader: task started");
+            
+            // Create channel for line communication
+            let (line_tx, mut line_rx) = mpsc::channel::<String>(10);
+            
+            // Spawn dedicated stdin reader task (this will block on stdin)
+            let reader_task = tokio::spawn(async move {
+                let stdin = tokio::io::stdin();
+                let reader = BufReader::new(stdin);
+                let mut lines = reader.lines();
+                
+                while let Ok(Some(line)) = lines.next_line().await {
+                    if line_tx.send(line).await.is_err() {
+                        break; // Channel closed
+                    }
+                }
+                tracing::info!("StructuredIO stdin reader: EOF reached or channel closed");
+            });
+            
+            // Processor loop with tokio::select! for responsive shutdown
+            loop {
+                tokio::select! {
+                    // Branch 1: Process incoming lines
+                    Some(line) = line_rx.recv() => {
+                        let line = line.trim();
+
+                        if line.is_empty() {
+                            continue;
+                        }
+
+                        // Try to parse as JSON command, otherwise treat as plain text prompt
+                        let result = if let Ok(json) = serde_json::from_str::<serde_json::Value>(line) {
+                            if let Some(cmd_str) = json.get("command").and_then(|v| v.as_str()) {
+                                match cmd_str {
+                                    "quit" => {
+                                        // Send shutdown command
+                                        if cmd_sender.send(PromptResult::Shutdown).await.is_ok() {
+                                            tracing::info!("StructuredIO: Quit command sent");
+                                        }
+                                        // Trigger internal shutdown
+                                        shutdown.notify_waiters();
+                                        break;
+                                    }
+                                    "prompt" => {
+                                        // Extract worker_id (optional) and text (required)
+                                        let worker_id = json
+                                            .get("worker_id")
+                                            .and_then(|v| v.as_str())
+                                            .and_then(|s| Uuid::parse_str(s).ok())
+                                            .or_else(|| {
+                                                // Default to first worker
+                                                session.get_workers().first().map(|w| w.id)
+                                            });
+
+                                        let text = json
+                                            .get("text")
+                                            .and_then(|v| v.as_str())
+                                            .unwrap_or("")
+                                            .to_string();
+
+                                        if let Some(wid) = worker_id {
+                                            PromptResult::Command(AgentEnvironmentCommand::Prompt {
+                                                worker_id: wid,
+                                                text,
+                                            })
+                                        } else {
+                                            // No workers available - skip
+                                            continue;
+                                        }
+                                    }
+                                    _ => {
+                                        // Unknown command - treat whole line as prompt
+                                        if let Some(worker_id) = session.get_workers().first().map(|w| w.id)
+                                        {
+                                            PromptResult::Command(AgentEnvironmentCommand::Prompt {
+                                                worker_id,
+                                                text: line.to_string(),
+                                            })
+                                        } else {
+                                            continue;
+                                        }
+                                    }
+                                }
+                            } else {
+                                // No command field - treat as prompt, extract text/prompt and worker_id
+                                let worker_id = json
+                                    .get("worker_id")
+                                    .and_then(|v| v.as_str())
+                                    .and_then(|s| Uuid::parse_str(s).ok())
+                                    .or_else(|| {
+                                        // Default to first worker
+                                        session.get_workers().first().map(|w| w.id)
+                                    });
+                                
+                                let text = json
+                                    .get("text")
+                                    .or_else(|| json.get("prompt"))
+                                    .and_then(|v| v.as_str())
+                                    .unwrap_or(line)
+                                    .to_string();
+                                
+                                if let Some(wid) = worker_id {
+                                    PromptResult::Command(AgentEnvironmentCommand::Prompt {
+                                        worker_id: wid,
+                                        text,
+                                    })
+                                } else {
+                                    continue;
+                                }
+                            }
+                        } else {
+                            // Not JSON - treat as plain text prompt
+                            if let Some(worker_id) = session.get_workers().first().map(|w| w.id) {
+                                PromptResult::Command(AgentEnvironmentCommand::Prompt {
+                                    worker_id,
+                                    text: line.to_string(),
+                                })
+                            } else {
+                                continue;
+                            }
+                        };
+
+                        if cmd_sender.send(result).await.is_err() {
+                            break; // Channel closed
+                        }
+                    }
+                    
+                    // Branch 2: Handle shutdown signal
+                    _ = shutdown.notified() => {
+                        tracing::info!("StructuredIO input reader: shutdown signal received");
+                        break;
+                    }
+                }
+            }
+            
+            // Abort reader task on shutdown
+            reader_task.abort();
+            let _ = reader_task.await; // Ignore JoinError from abort
+            tracing::info!("StructuredIO input reader: task exited");
+        })
+    }
+}
+
+#[async_trait]
+impl UserInterface for StructuredIO {
+    async fn start(&self) -> Result<()> {
+        if self.interactive {
+            tracing::info!("StructuredIO: Starting input reader");
+            let _handle = self.spawn_input_reader();
+        } else {
+            tracing::info!("StructuredIO: Non-interactive mode, skipping input reader");
+        }
+        Ok(())
+    }
+
+    fn command_receiver(&self) -> mpsc::Receiver<PromptResult> {
+        // Use try_lock since we're in sync context but called from async
+        self.cmd_receiver
+            .try_lock()
+            .expect("command_receiver() called while locked")
+            .take()
+            .expect("command_receiver() called more than once")
+    }
+
+    async fn handle_event(&self, event: AgentEnvironmentEvent) {
+        // Handle events
+        match event {
+            AgentEnvironmentEvent::Worker(WorkerEvent::Created {
+                worker_id,
+                name,
+                timestamp,
+            }) => {
+                let json = json!({
+                    "event": "worker_created",
+                    "worker_id": worker_id,
+                    "name": name,
+                    "timestamp": format!("{:?}", timestamp),
+                });
+
+                let mut writer = self.output_writer.lock().await;
+                writeln!(writer, "{}", json.to_string().white().dimmed()).unwrap();
+                writer.flush().unwrap();
+            }
+            AgentEnvironmentEvent::Worker(WorkerEvent::Deleted {
+                worker_id,
+                timestamp,
+            }) => {
+                let json = json!({
+                    "event": "worker_deleted",
+                    "worker_id": worker_id,
+                    "timestamp": format!("{:?}", timestamp),
+                });
+
+                let mut writer = self.output_writer.lock().await;
+                writeln!(writer, "{}", json.to_string().white().dimmed()).unwrap();
+                writer.flush().unwrap();
+            }
+            AgentEnvironmentEvent::Worker(WorkerEvent::LifecycleStateChanged {
+                worker_id,
+                new_state,
+                ..
+            }) => {
+                let state_str = match new_state {
+                    WorkerLifecycleState::Idle => "idle",
+                    WorkerLifecycleState::Busy => "busy",
+                    WorkerLifecycleState::IdleFailed => "idle_failed",
+                };
+
+                let json = json!({
+                    "worker_id": worker_id,
+                    "lifecycle_state": state_str,
+                });
+
+                let mut writer = self.output_writer.lock().await;
+                writeln!(writer, "{}", json.to_string().white().dimmed()).unwrap();
+                writer.flush().unwrap();
+            }
+            AgentEnvironmentEvent::Job(JobEvent::Started {
+                worker_id,
+                job_id,
+                task_type,
+                timestamp,
+            }) => {
+                let json = json!({
+                    "event": "job_started",
+                    "worker_id": worker_id,
+                    "job_id": job_id,
+                    "task_type": task_type,
+                    "timestamp": format!("{:?}", timestamp),
+                });
+
+                let mut writer = self.output_writer.lock().await;
+                writeln!(writer, "{}", json.to_string().white().dimmed()).unwrap();
+                writer.flush().unwrap();
+            }
+            AgentEnvironmentEvent::Job(JobEvent::Completed {
+                worker_id,
+                job_id,
+                result,
+                timestamp,
+            }) => {
+                let result_str = match result {
+                    JobCompletionResult::Success { .. } => "success",
+                    JobCompletionResult::Cancelled => "cancelled",
+                    JobCompletionResult::Failed { .. } => "failed",
+                };
+
+                let json = json!({
+                    "event": "job_completed",
+                    "worker_id": worker_id,
+                    "job_id": job_id,
+                    "result": result_str,
+                    "timestamp": format!("{:?}", timestamp),
+                });
+
+                let mut writer = self.output_writer.lock().await;
+                let output = match result {
+                    JobCompletionResult::Failed { .. } => json.to_string().red().to_string(),
+                    _ => json.to_string().white().dimmed().to_string(),
+                };
+                writeln!(writer, "{}", output).unwrap();
+                writer.flush().unwrap();
+            }
+            AgentEnvironmentEvent::AgentLoop(AgentLoopEvent::ResponseReceived {
+                worker_id,
+                text,
+                ..
+            }) => {
+                let json = json!({
+                    "worker_id": worker_id,
+                    "assistant_response": text,
+                });
+
+                let mut writer = self.output_writer.lock().await;
+                writeln!(writer, "{}", json).unwrap();
+                writer.flush().unwrap();
+            }
+            AgentEnvironmentEvent::AgentLoop(AgentLoopEvent::ToolUseRequestReceived {
+                worker_id,
+                tool_name,
+                tool_input,
+                ..
+            }) => {
+                let json = json!({
+                    "worker_id": worker_id,
+                    "tool_use_request": {
+                        "tool_name": tool_name,
+                        "tool_input": tool_input,
+                    }
+                });
+
+                let mut writer = self.output_writer.lock().await;
+                writeln!(writer, "{}", json).unwrap();
+                writer.flush().unwrap();
+            }
+            AgentEnvironmentEvent::WebUI(crate::agent_env::events::WebUIEvent::PromptReceived {
+                worker_id,
+                text,
+                ..
+            }) => {
+                let json = json!({
+                    "event": "webui_prompt",
+                    "worker_id": worker_id,
+                    "text": text,
+                });
+
+                let mut writer = self.output_writer.lock().await;
+                writeln!(writer, "{}", json.to_string().cyan()).unwrap();
+                writer.flush().unwrap();
+            }
+            AgentEnvironmentEvent::WebUI(crate::agent_env::events::WebUIEvent::ServerStarted {
+                address,
+                ..
+            }) => {
+                let json = json!({
+                    "event": "webui_server_started",
+                    "address": address,
+                });
+
+                let mut writer = self.output_writer.lock().await;
+                writeln!(writer, "{}", json.to_string().bright_blue()).unwrap();
+                writer.flush().unwrap();
+            }
+            AgentEnvironmentEvent::WebUI(crate::agent_env::events::WebUIEvent::WebSocketConnected {
+                ..
+            }) => {
+                let json = json!({
+                    "event": "webui_websocket_connected",
+                });
+
+                let mut writer = self.output_writer.lock().await;
+                writeln!(writer, "{}", json.to_string().bright_blue()).unwrap();
+                writer.flush().unwrap();
+            }
+            _ => {}
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::agent_env::{
+        events::AgentLoopEvent, model_providers::ModelProvider, EventBus, ModelResponseChunk,
+    };
+    use async_trait::async_trait;
+    use eyre::Result;
+
+    // Mock ModelProvider for testing
+    struct MockModelProvider;
+
+    #[async_trait]
+    impl ModelProvider for MockModelProvider {
+        async fn request(
+            &self,
+            _request: crate::agent_env::ModelRequest,
+            _when_receiving_begin: Box<dyn Fn() + Send>,
+            _when_received: Box<dyn Fn(ModelResponseChunk) + Send>,
+            _cancellation_token: tokio_util::sync::CancellationToken,
+        ) -> Result<crate::agent_env::ModelResponse, eyre::Error> {
+            Ok(crate::agent_env::ModelResponse {
+                content: String::new(),
+                tool_requests: vec![],
+            })
+        }
+    }
+
+    fn create_test_session() -> Arc<Session> {
+        let event_bus = EventBus::default();
+        let model_provider: Arc<dyn ModelProvider> = Arc::new(MockModelProvider);
+        Arc::new(Session::new(event_bus, vec![model_provider]))
+    }
+
+    #[tokio::test]
+    async fn test_structured_io_outputs_events_for_all_workers() {
+        let session = create_test_session();
+        let main_worker = session.build_worker("main".to_string());
+        let other_worker = session.build_worker("other".to_string());
+
+        let structured_io = StructuredIO::new(session.clone(), true).unwrap();
+
+        // Event for main worker - should be processed
+        let event1 = AgentEnvironmentEvent::AgentLoop(AgentLoopEvent::ResponseReceived {
+            worker_id: main_worker.id,
+            job_id: Uuid::new_v4(),
+            text: "Response for main".to_string(),
+            timestamp: std::time::Instant::now(),
+        });
+
+        // Event for other worker - should also be processed
+        let event2 = AgentEnvironmentEvent::AgentLoop(AgentLoopEvent::ResponseReceived {
+            worker_id: other_worker.id,
+            job_id: Uuid::new_v4(),
+            text: "Response for other".to_string(),
+            timestamp: std::time::Instant::now(),
+        });
+
+        // Both should complete without error
+        structured_io.handle_event(event1).await;
+        structured_io.handle_event(event2).await;
+    }
+
+    #[tokio::test]
+    async fn test_structured_io_outputs_json_for_response() {
+        let session = create_test_session();
+        let main_worker = session.build_worker("main".to_string());
+
+        let structured_io = StructuredIO::new(session.clone(), true).unwrap();
+
+        let event = AgentEnvironmentEvent::AgentLoop(AgentLoopEvent::ResponseReceived {
+            worker_id: main_worker.id,
+            job_id: Uuid::new_v4(),
+            text: "Test response".to_string(),
+            timestamp: std::time::Instant::now(),
+        });
+
+        // Should output JSON without error
+        structured_io.handle_event(event).await;
+    }
+
+    #[tokio::test]
+    async fn test_structured_io_outputs_json_for_tool_use() {
+        let session = create_test_session();
+        let main_worker = session.build_worker("main".to_string());
+
+        let structured_io = StructuredIO::new(session.clone(), true).unwrap();
+
+        let event = AgentEnvironmentEvent::AgentLoop(AgentLoopEvent::ToolUseRequestReceived {
+            worker_id: main_worker.id,
+            job_id: Uuid::new_v4(),
+            tool_name: "test_tool".to_string(),
+            tool_input: serde_json::json!({"arg": "value"}),
+            timestamp: std::time::Instant::now(),
+        });
+
+        // Should output JSON without error
+        structured_io.handle_event(event).await;
+    }
+
+    #[tokio::test]
+    async fn test_command_receiver_single_use() {
+        let session = create_test_session();
+        let _main_worker = session.build_worker("main".to_string());
+
+        let structured_io = StructuredIO::new(session.clone(), true).unwrap();
+
+        // First call should succeed
+        let _receiver = structured_io.command_receiver();
+
+        // Test passes - we verified first call works
+        // Second call would panic but we can't easily test that
+    }
+
+    #[tokio::test]
+    async fn test_worker_created_event_handler() {
+        use crate::agent_env::events::WorkerEvent;
+        
+        let session = create_test_session();
+        let structured_io = StructuredIO::new(session.clone(), true).unwrap();
+        
+        let worker_id = Uuid::new_v4();
+        let event = AgentEnvironmentEvent::Worker(WorkerEvent::Created {
+            worker_id,
+            name: "test_worker".to_string(),
+            timestamp: std::time::Instant::now(),
+        });
+        
+        // Should output JSON without error
+        structured_io.handle_event(event).await;
+    }
+
+    #[tokio::test]
+    async fn test_worker_deleted_event_handler() {
+        use crate::agent_env::events::WorkerEvent;
+        
+        let session = create_test_session();
+        let structured_io = StructuredIO::new(session.clone(), true).unwrap();
+        
+        let worker_id = Uuid::new_v4();
+        let event = AgentEnvironmentEvent::Worker(WorkerEvent::Deleted {
+            worker_id,
+            timestamp: std::time::Instant::now(),
+        });
+        
+        // Should output JSON without error
+        structured_io.handle_event(event).await;
+    }
+
+    #[tokio::test]
+    async fn test_job_started_event_handler() {
+        use crate::agent_env::events::JobEvent;
+        
+        let session = create_test_session();
+        let structured_io = StructuredIO::new(session.clone(), true).unwrap();
+        
+        let event = AgentEnvironmentEvent::Job(JobEvent::Started {
+            worker_id: Uuid::new_v4(),
+            job_id: Uuid::new_v4(),
+            task_type: "AgentLoop".to_string(),
+            timestamp: std::time::Instant::now(),
+        });
+        
+        // Should output JSON without error
+        structured_io.handle_event(event).await;
+    }
+
+    #[tokio::test]
+    async fn test_job_completed_event_handler_success() {
+        use crate::agent_env::events::{JobEvent, JobCompletionResult, UserInteractionRequired};
+        
+        let session = create_test_session();
+        let structured_io = StructuredIO::new(session.clone(), true).unwrap();
+        
+        let event = AgentEnvironmentEvent::Job(JobEvent::Completed {
+            worker_id: Uuid::new_v4(),
+            job_id: Uuid::new_v4(),
+            result: JobCompletionResult::Success {
+                task_metadata: std::collections::HashMap::new(),
+                user_interaction_required: UserInteractionRequired::None,
+            },
+            timestamp: std::time::Instant::now(),
+        });
+        
+        // Should output JSON without error
+        structured_io.handle_event(event).await;
+    }
+
+    #[tokio::test]
+    async fn test_job_completed_event_handler_failed() {
+        use crate::agent_env::events::{JobEvent, JobCompletionResult};
+        
+        let session = create_test_session();
+        let structured_io = StructuredIO::new(session.clone(), true).unwrap();
+        
+        let event = AgentEnvironmentEvent::Job(JobEvent::Completed {
+            worker_id: Uuid::new_v4(),
+            job_id: Uuid::new_v4(),
+            result: JobCompletionResult::Failed {
+                error: "test error".to_string(),
+            },
+            timestamp: std::time::Instant::now(),
+        });
+        
+        // Should output JSON without error
+        structured_io.handle_event(event).await;
+    }
+
+    #[tokio::test]
+    async fn test_job_completed_event_handler_cancelled() {
+        use crate::agent_env::events::{JobEvent, JobCompletionResult};
+        
+        let session = create_test_session();
+        let structured_io = StructuredIO::new(session.clone(), true).unwrap();
+        
+        let event = AgentEnvironmentEvent::Job(JobEvent::Completed {
+            worker_id: Uuid::new_v4(),
+            job_id: Uuid::new_v4(),
+            result: JobCompletionResult::Cancelled,
+            timestamp: std::time::Instant::now(),
+        });
+        
+        // Should output JSON without error
+        structured_io.handle_event(event).await;
+    }
+}
diff --git a/crates/chat-cli/src/cli/chat/agent_env_ui/text_ui.rs b/crates/chat-cli/src/cli/chat/agent_env_ui/text_ui.rs
new file mode 100644
index 000000000..fd2c85a76
--- /dev/null
+++ b/crates/chat-cli/src/cli/chat/agent_env_ui/text_ui.rs
@@ -0,0 +1,371 @@
+use crate::agent_env::{
+    AgentEnvironmentEvent, AgentEnvironmentCommand, Command, PromptResult,
+    Session, WorkerEvent, JobEvent, OutputChunk, WorkerLifecycleState,
+    CommandParser,
+};
+use super::{InputHandler, ui_utils};
+use tokio::sync::{mpsc, Notify};
+use std::sync::Arc;
+use std::path::PathBuf;
+use std::io::{self, Write};
+use uuid::Uuid;
+use async_trait::async_trait;
+use tokio::task::JoinHandle;
+
+/// Text-based UI with readline-style input and streaming output
+pub struct TextUi {
+    session: Arc<Session>,
+    main_worker_id: Uuid,
+    input_handler: Arc<tokio::sync::Mutex<InputHandler>>,
+    cmd_sender: mpsc::Sender<PromptResult>,
+    cmd_receiver: Arc<std::sync::Mutex<Option<mpsc::Receiver<PromptResult>>>>,
+    prompt_ready: Arc<Notify>,
+    shutdown_signal: Arc<Notify>,
+    interactive: bool,
+}
+
+impl TextUi {
+    /// Create new TextUi
+    pub fn new(
+        session: Arc<Session>,
+        main_worker_id: Uuid,
+        history_path: Option<PathBuf>,
+        interactive: bool,
+    ) -> Result<Self, eyre::Error> {
+        let (cmd_sender, cmd_receiver) = mpsc::channel(10);
+        
+        Ok(Self {
+            session,
+            main_worker_id,
+            input_handler: Arc::new(tokio::sync::Mutex::new(InputHandler::new(history_path)?)),
+            cmd_sender,
+            cmd_receiver: Arc::new(std::sync::Mutex::new(Some(cmd_receiver))),
+            prompt_ready: Arc::new(Notify::new()),
+            shutdown_signal: Arc::new(Notify::new()),
+            interactive,
+        })
+    }
+    
+    /// Spawn prompt loop task
+    fn spawn_prompt_loop(&self) -> JoinHandle<()> {
+        let input_handler = self.input_handler.clone();
+        let cmd_sender = self.cmd_sender.clone();
+        let session = self.session.clone();
+        let main_worker_id = self.main_worker_id;
+        let prompt_ready = self.prompt_ready.clone();
+        let shutdown = self.shutdown_signal.clone();
+        
+        tokio::spawn(async move {
+            loop {
+                tokio::select! {
+                    // Wait for worker to be ready for input
+                    _ = prompt_ready.notified() => {
+                        // Read input (blocking, but in separate task)
+                        let mut handler = input_handler.lock().await;
+                        let input = match handler.read_line("You").await {
+                            Ok(input) => input,
+                            Err(e) => {
+                                eprintln!("Error reading input: {}", e);
+                                continue;
+                            }
+                        };
+                        drop(handler); // Release lock
+                        
+                        // Parse command
+                        let command = match CommandParser::parse(&input) {
+                            Ok(cmd) => cmd,
+                            Err(e) => {
+                                eprintln!("Error parsing command: {}", e);
+                                // Re-signal for next prompt
+                                prompt_ready.notify_one();
+                                continue;
+                            }
+                        };
+                        
+                        match command {
+                            // UI-specific commands - handle internally
+                            Command::Ui(ui_cmd) => {
+                                use crate::agent_env::UiCommand;
+                                match ui_cmd {
+                                    UiCommand::Usage => {
+                                        if let Some(worker) = session.get_worker(main_worker_id) {
+                                            let usage = ui_utils::calculate_token_usage(&worker);
+                                            println!("Token usage:");
+                                            println!("  Input:  {}", usage.input_tokens);
+                                            println!("  Output: {}", usage.output_tokens);
+                                            println!("  Total:  {}", usage.total_tokens);
+                                        }
+                                        // Re-signal for next prompt
+                                        prompt_ready.notify_one();
+                                    }
+                                    UiCommand::Context => {
+                                        if let Some(worker) = session.get_worker(main_worker_id) {
+                                            let info = ui_utils::format_context_info(&worker);
+                                            println!("{}", info);
+                                        }
+                                        // Re-signal for next prompt
+                                        prompt_ready.notify_one();
+                                    }
+                                    UiCommand::Status => {
+                                        if let Some(worker) = session.get_worker(main_worker_id) {
+                                            let state = worker.lifecycle_state.lock().unwrap();
+                                            println!("Worker status: {:?}", *state);
+                                        }
+                                        // Re-signal for next prompt
+                                        prompt_ready.notify_one();
+                                    }
+                                    UiCommand::Workers => {
+                                        println!("Workers:");
+                                        println!("  Main worker: {}", main_worker_id);
+                                        // Re-signal for next prompt
+                                        prompt_ready.notify_one();
+                                    }
+                                }
+                            }
+                            
+                            // Task-spawning commands - send to AgentEnvironment
+                            Command::Agent(mut agent_cmd) => {
+                                // Fill in worker_id
+                                match &mut agent_cmd {
+                                    AgentEnvironmentCommand::Prompt { worker_id, .. } => {
+                                        *worker_id = main_worker_id;
+                                    }
+                                    AgentEnvironmentCommand::Compact { worker_id, .. } => {
+                                        *worker_id = main_worker_id;
+                                    }
+                                    AgentEnvironmentCommand::Quit => {}
+                                }
+                                
+                                // Send command
+                                if cmd_sender.send(PromptResult::Command(agent_cmd)).await.is_err() {
+                                    break; // Channel closed
+                                }
+                            }
+                        }
+                    }
+                    _ = shutdown.notified() => break,
+                }
+            }
+        })
+    }
+}
+
+#[async_trait]
+impl crate::agent_env::UserInterface for TextUi {
+    async fn start(&self) -> Result<(), eyre::Error> {
+        // Spawn prompt loop task only in interactive mode
+        if self.interactive {
+            tracing::info!("TextUi: Starting prompt loop");
+            self.spawn_prompt_loop();
+            
+            // Check if worker is already Idle and signal prompt_ready if so
+            let worker = self.session.get_worker(self.main_worker_id)
+                .ok_or_else(|| eyre::eyre!("Worker not found"))?;
+            let current_state = *worker.lifecycle_state.lock().unwrap();
+            if current_state == WorkerLifecycleState::Idle {
+                tracing::info!("TextUi: Worker is idle, enabling prompt");
+                self.prompt_ready.notify_one();
+            }
+        } else {
+            tracing::info!("TextUi: Non-interactive mode, skipping prompt loop");
+        }
+        
+        Ok(())
+    }
+    
+    fn command_receiver(&self) -> mpsc::Receiver<PromptResult> {
+        self.cmd_receiver
+            .lock()
+            .unwrap()
+            .take()
+            .expect("command_receiver() called more than once")
+    }
+    
+    async fn handle_event(&self, event: AgentEnvironmentEvent) {
+        // Filter to main worker
+        if let Some(wid) = event.worker_id() {
+            if wid != self.main_worker_id {
+                return;
+            }
+        }
+        
+        // Handle event
+        match event {
+            AgentEnvironmentEvent::Job(JobEvent::OutputChunk { chunk, .. }) => {
+                match chunk {
+                    OutputChunk::AssistantResponse(text) => {
+                        print!("{}", text);
+                        io::stdout().flush().unwrap();
+                    }
+                    OutputChunk::ToolUse { tool_name, .. } => {
+                        println!("\n[Using tool: {}]", tool_name);
+                    }
+                    OutputChunk::ToolResult { tool_name, .. } => {
+                        println!("[Tool {} completed]", tool_name);
+                    }
+                }
+            }
+            AgentEnvironmentEvent::Worker(WorkerEvent::LifecycleStateChanged { new_state, .. }) => {
+                match new_state {
+                    WorkerLifecycleState::Busy => {
+                        // Worker started job - don't prompt
+                    }
+                    WorkerLifecycleState::Idle => {
+                        println!(); // New line after completion
+                        // Signal prompt loop to read input
+                        self.prompt_ready.notify_one();
+                    }
+                    WorkerLifecycleState::IdleFailed => {
+                        println!("\n[Task failed]");
+                        // Still allow prompt
+                        self.prompt_ready.notify_one();
+                    }
+                }
+            }
+            _ => {}
+        }
+    }
+}
+
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::agent_env::{EventBus, WorkerLifecycleState, UserInterface};
+    use crate::agent_env::model_providers::{ModelProvider, ModelRequest, ModelResponse, ModelResponseChunk};
+    use async_trait::async_trait;
+    use tokio_util::sync::CancellationToken;
+
+    struct MockModelProvider;
+
+    #[async_trait]
+    impl ModelProvider for MockModelProvider {
+        async fn request(
+            &self,
+            _request: ModelRequest,
+            _when_receiving_begin: Box<dyn Fn() + Send>,
+            _when_received: Box<dyn Fn(ModelResponseChunk) + Send>,
+            _cancellation_token: CancellationToken,
+        ) -> Result<ModelResponse, eyre::Error> {
+            Ok(ModelResponse {
+                content: "test".to_string(),
+                tool_requests: vec![],
+            })
+        }
+    }
+
+    fn create_test_session() -> Arc<Session> {
+        let event_bus = EventBus::default();
+        let model_provider = Arc::new(MockModelProvider);
+        Arc::new(Session::new(event_bus, vec![model_provider]))
+    }
+
+    #[tokio::test]
+    async fn test_event_filtering() {
+        let session = create_test_session();
+        let worker1 = session.build_worker("worker1".to_string());
+        let worker2 = session.build_worker("worker2".to_string());
+        
+        let text_ui = TextUi::new(session.clone(), worker1.id, None, true).unwrap();
+        
+        // Event for worker1 should be processed (main_worker_id)
+        let event1 = AgentEnvironmentEvent::Worker(WorkerEvent::LifecycleStateChanged {
+            worker_id: worker1.id,
+            old_state: WorkerLifecycleState::Idle,
+            new_state: WorkerLifecycleState::Busy,
+            timestamp: std::time::Instant::now(),
+        });
+        
+        // Event for worker2 should be filtered out
+        let event2 = AgentEnvironmentEvent::Worker(WorkerEvent::LifecycleStateChanged {
+            worker_id: worker2.id,
+            old_state: WorkerLifecycleState::Idle,
+            new_state: WorkerLifecycleState::Busy,
+            timestamp: std::time::Instant::now(),
+        });
+        
+        // Both calls should succeed (filtering happens inside handle_event)
+        text_ui.handle_event(event1).await;
+        text_ui.handle_event(event2).await;
+    }
+
+    #[tokio::test]
+    async fn test_output_chunk_display() {
+        let session = create_test_session();
+        let worker = session.build_worker("test".to_string());
+        
+        let text_ui = TextUi::new(session.clone(), worker.id, None, true).unwrap();
+        
+        // Test assistant response chunk
+        let event = AgentEnvironmentEvent::Job(crate::agent_env::JobEvent::OutputChunk {
+            worker_id: worker.id,
+            job_id: uuid::Uuid::new_v4(),
+            chunk: OutputChunk::AssistantResponse("Hello".to_string()),
+            timestamp: std::time::Instant::now(),
+        });
+        
+        text_ui.handle_event(event).await;
+        
+        // Test tool use chunk
+        let event = AgentEnvironmentEvent::Job(crate::agent_env::JobEvent::OutputChunk {
+            worker_id: worker.id,
+            job_id: uuid::Uuid::new_v4(),
+            chunk: OutputChunk::ToolUse {
+                tool_name: "test_tool".to_string(),
+                tool_input: serde_json::json!({}),
+            },
+            timestamp: std::time::Instant::now(),
+        });
+        
+        text_ui.handle_event(event).await;
+    }
+
+    #[tokio::test]
+    async fn test_lifecycle_state_transitions() {
+        let session = create_test_session();
+        let worker = session.build_worker("test".to_string());
+        
+        let text_ui = TextUi::new(session.clone(), worker.id, None, true).unwrap();
+        
+        // Test transition to Busy (should not signal prompt)
+        let event = AgentEnvironmentEvent::Worker(WorkerEvent::LifecycleStateChanged {
+            worker_id: worker.id,
+            old_state: WorkerLifecycleState::Idle,
+            new_state: WorkerLifecycleState::Busy,
+            timestamp: std::time::Instant::now(),
+        });
+        text_ui.handle_event(event).await;
+        
+        // Test transition to Idle (should signal prompt)
+        let event = AgentEnvironmentEvent::Worker(WorkerEvent::LifecycleStateChanged {
+            worker_id: worker.id,
+            old_state: WorkerLifecycleState::Busy,
+            new_state: WorkerLifecycleState::Idle,
+            timestamp: std::time::Instant::now(),
+        });
+        text_ui.handle_event(event).await;
+        
+        // Test transition to IdleFailed (should signal prompt)
+        let event = AgentEnvironmentEvent::Worker(WorkerEvent::LifecycleStateChanged {
+            worker_id: worker.id,
+            old_state: WorkerLifecycleState::Busy,
+            new_state: WorkerLifecycleState::IdleFailed,
+            timestamp: std::time::Instant::now(),
+        });
+        text_ui.handle_event(event).await;
+    }
+
+    #[tokio::test]
+    async fn test_command_receiver_single_use() {
+        let session = create_test_session();
+        let worker = session.build_worker("test".to_string());
+        
+        let text_ui = TextUi::new(session.clone(), worker.id, None, true).unwrap();
+        
+        // First call should succeed
+        let _receiver = text_ui.command_receiver();
+        
+        // Note: Second call would panic, but we can't test that easily without UnwindSafe
+        // The panic behavior is documented in the method
+    }
+}
diff --git a/crates/chat-cli/src/cli/chat/agent_env_ui/ui_utils.rs b/crates/chat-cli/src/cli/chat/agent_env_ui/ui_utils.rs
new file mode 100644
index 000000000..d6f47db25
--- /dev/null
+++ b/crates/chat-cli/src/cli/chat/agent_env_ui/ui_utils.rs
@@ -0,0 +1,180 @@
+/// Shared utilities for UI implementations
+///
+/// This module provides common functionality used by different UI implementations,
+/// such as token usage calculation and context information formatting.
+
+use crate::agent_env::{Worker, WorkerLifecycleState};
+use crate::agent_env::context_container::ConversationEntry;
+
+/// Token usage statistics for a worker
+#[derive(Debug, Clone)]
+pub struct TokenUsage {
+    pub input_tokens: usize,
+    pub output_tokens: usize,
+    pub total_tokens: usize,
+}
+
+/// Estimate token count for text
+///
+/// Simple estimation: approximately 4 characters per token
+fn estimate_tokens(text: &str) -> usize {
+    text.len() / 4
+}
+
+/// Calculate token usage for a worker
+///
+/// Iterates through the conversation history and estimates token counts
+/// for input (user) and output (assistant) messages.
+pub fn calculate_token_usage(worker: &Worker) -> TokenUsage {
+    let history = worker.context_container
+        .conversation_history
+        .lock()
+        .unwrap();
+    
+    let mut input_tokens = 0;
+    let mut output_tokens = 0;
+    
+    for entry in history.get_entries() {
+        // Count user message tokens if present
+        if let Some(user_msg) = &entry.user {
+            if let Some(prompt) = user_msg.prompt() {
+                input_tokens += estimate_tokens(prompt);
+            }
+        }
+        
+        // Count assistant message tokens if present
+        if let Some(asst_msg) = &entry.assistant {
+            output_tokens += estimate_tokens(asst_msg.content());
+        }
+    }
+    
+    TokenUsage {
+        input_tokens,
+        output_tokens,
+        total_tokens: input_tokens + output_tokens,
+    }
+}
+
+/// Format context information for display
+///
+/// Returns a formatted string with worker name, message count, and lifecycle state.
+pub fn format_context_info(worker: &Worker) -> String {
+    let history = worker.context_container
+        .conversation_history
+        .lock()
+        .unwrap();
+    
+    let lifecycle_state = worker.lifecycle_state.lock().unwrap();
+    
+    format!(
+        "Worker: {}\nMessages: {}\nState: {:?}",
+        worker.name,
+        history.len(),
+        *lifecycle_state
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::agent_env::{ContextContainer, WorkerStates};
+    use crate::cli::chat::message::AssistantMessage;
+    use std::sync::{Arc, Mutex};
+    use std::collections::HashMap;
+    use uuid::Uuid;
+
+    fn create_test_worker() -> Worker {
+        Worker {
+            id: Uuid::new_v4(),
+            name: "test_worker".to_string(),
+            lifecycle_state: Arc::new(Mutex::new(WorkerLifecycleState::Idle)),
+            task_metadata: Arc::new(Mutex::new(HashMap::new())),
+            context_container: ContextContainer::new(),
+            model_provider: None,
+            os: Arc::new(Mutex::new(None)),
+            state: Arc::new(Mutex::new(WorkerStates::Inactive)),
+            last_failure: Arc::new(Mutex::new(None)),
+        }
+    }
+
+    #[test]
+    fn test_estimate_tokens() {
+        assert_eq!(estimate_tokens(""), 0);
+        assert_eq!(estimate_tokens("test"), 1); // 4 chars = 1 token
+        assert_eq!(estimate_tokens("hello world"), 2); // 11 chars = 2 tokens
+        assert_eq!(estimate_tokens("a".repeat(100).as_str()), 25); // 100 chars = 25 tokens
+    }
+
+    #[test]
+    fn test_calculate_token_usage_empty() {
+        let worker = create_test_worker();
+        let usage = calculate_token_usage(&worker);
+        
+        assert_eq!(usage.input_tokens, 0);
+        assert_eq!(usage.output_tokens, 0);
+        assert_eq!(usage.total_tokens, 0);
+    }
+
+    #[test]
+    fn test_calculate_token_usage_with_messages() {
+        let worker = create_test_worker();
+        
+        // Add some messages
+        {
+            let mut history = worker.context_container
+                .conversation_history
+                .lock()
+                .unwrap();
+            
+            history.push_input_message("Hello, how are you?".to_string()); // 19 chars = 4 tokens
+            history.push_assistant_message(AssistantMessage::new_response(
+                None,
+                "I'm doing well, thank you!".to_string() // 27 chars = 6 tokens
+            ));
+        }
+        
+        let usage = calculate_token_usage(&worker);
+        
+        // "Hello, how are you?" = 19 chars = 4 tokens
+        // "I'm doing well, thank you!" = 27 chars = 6 tokens
+        assert_eq!(usage.input_tokens, 4);
+        assert_eq!(usage.output_tokens, 6);
+        assert_eq!(usage.total_tokens, 10);
+    }
+
+    #[test]
+    fn test_format_context_info() {
+        let worker = create_test_worker();
+        
+        // Add a message
+        {
+            let mut history = worker.context_container
+                .conversation_history
+                .lock()
+                .unwrap();
+            
+            history.push_input_message("Test message".to_string());
+        }
+        
+        let info = format_context_info(&worker);
+        
+        assert!(info.contains("Worker: test_worker"));
+        assert!(info.contains("Messages: 1"));
+        assert!(info.contains("State: Idle"));
+    }
+
+    #[test]
+    fn test_format_context_info_busy_state() {
+        let worker = create_test_worker();
+        
+        // Set worker to Busy state
+        {
+            let mut state = worker.lifecycle_state.lock().unwrap();
+            *state = WorkerLifecycleState::Busy;
+        }
+        
+        let info = format_context_info(&worker);
+        
+        assert!(info.contains("State: Busy"));
+    }
+}
diff --git a/crates/chat-cli/src/cli/chat/message.rs b/crates/chat-cli/src/cli/chat/message.rs
index 569846c1c..5baaed1c4 100644
--- a/crates/chat-cli/src/cli/chat/message.rs
+++ b/crates/chat-cli/src/cli/chat/message.rs
@@ -289,7 +289,7 @@ impl UserMessage {
 
     /// Returns a formatted [String] containing [Self::additional_context], [Self::timestamp], and
     /// [Self::prompt].
-    fn content_with_context(&self) -> String {
+    pub fn content_with_context(&self) -> String {
         let mut content = String::new();
 
         if let Some(ts) = self.timestamp {
diff --git a/crates/chat-cli/src/cli/chat/mod.rs b/crates/chat-cli/src/cli/chat/mod.rs
index a1cc37535..7b70b630c 100644
--- a/crates/chat-cli/src/cli/chat/mod.rs
+++ b/crates/chat-cli/src/cli/chat/mod.rs
@@ -6,7 +6,7 @@ pub mod context;
 mod conversation;
 mod custom_spinner;
 mod input_source;
-mod message;
+pub mod message;
 mod parse;
 use std::path::MAIN_SEPARATOR;
 pub mod checkpoint;
@@ -15,6 +15,8 @@ mod parser;
 mod prompt;
 mod prompt_parser;
 pub mod server_messenger;
+pub mod agent_env_ui;
+pub mod web_server;
 use crate::cli::chat::checkpoint::CHECKPOINT_MESSAGE_MAX_LENGTH;
 use crate::constants::ui_text;
 #[cfg(unix)]
@@ -66,7 +68,6 @@ use clap::{
 use cli::compact::CompactStrategy;
 use cli::hooks::ToolContext;
 use cli::model::{
-    find_model,
     get_available_models,
     select_model,
 };
@@ -87,7 +88,6 @@ use custom_spinner::Spinners;
 use eyre::{
     Report,
     Result,
-    bail,
     eyre,
 };
 use input_source::InputSource;
@@ -116,16 +116,10 @@ use tokio::sync::{
     Mutex,
     broadcast,
 };
-use tool_manager::{
-    PromptQuery,
-    PromptQueryResult,
-    ToolManager,
-    ToolManagerBuilder,
-};
+use tool_manager::ToolManager;
 use tools::delegate::status_all_agents;
 use tools::gh_issue::GhIssueContext;
 use tools::{
-    NATIVE_TOOLS,
     OutputKind,
     QueuedTool,
     Tool,
@@ -184,7 +178,6 @@ use crate::constants::{
 use crate::database::settings::Setting;
 use crate::os::Os;
 use crate::telemetry::core::{
-    AgentConfigInitArgs,
     ChatAddedMessageParams,
     ChatConversationType,
     MessageMetaTag,
@@ -213,6 +206,32 @@ pub enum WrapMode {
     Auto,
 }
 
+/// UI mode selection
+#[derive(Debug, Clone, Copy, PartialEq, Eq, ValueEnum)]
+pub enum UiMode {
+    /// Text-based interactive UI with readline-style input
+    Text,
+    /// Structured JSON I/O for scripting and automation
+    Structured,
+    /// Headless mode with no UI (for background processing)
+    None,
+}
+
+/// Platform selection for LLM provider
+#[derive(Debug, Clone, Copy, PartialEq, Eq, ValueEnum)]
+pub enum Platform {
+    #[value(name = "bedrock")]
+    Bedrock,
+    #[value(name = "codewhisperer")]
+    CodeWhisperer,
+}
+
+impl Default for Platform {
+    fn default() -> Self {
+        Platform::CodeWhisperer
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Eq, Default, Args)]
 pub struct ChatArgs {
     /// Resumes the previous conversation from this directory.
@@ -239,214 +258,250 @@ pub struct ChatArgs {
     /// Control line wrapping behavior (default: auto-detect)
     #[arg(short = 'w', long, value_enum)]
     pub wrap: Option<WrapMode>,
+    /// UI mode to use (text, structured, or none)
+    #[arg(long = "ui-mode", value_enum)]
+    pub ui_mode: Option<UiMode>,
+    /// Platform to use for LLM
+    #[arg(long = "platform", value_enum)]
+    pub platform: Option<Platform>,
+    /// Enable web UI
+    #[arg(long)]
+    pub web_ui: bool,
+    /// Web UI port (default: 8080)
+    #[arg(long)]
+    pub web_port: Option<u16>,
 }
 
 impl ChatArgs {
-    pub async fn execute(mut self, os: &mut Os) -> Result<ExitCode> {
-        let mut input = self.input;
-
-        if self.no_interactive && input.is_none() {
-            if !std::io::stdin().is_terminal() {
-                let mut buffer = String::new();
-                match std::io::stdin().read_to_string(&mut buffer) {
-                    Ok(_) => {
-                        if !buffer.trim().is_empty() {
-                            input = Some(buffer.trim().to_string());
-                        }
-                    },
-                    Err(e) => {
-                        eprintln!("Error reading from stdin: {}", e);
-                    },
-                }
-            }
-
-            if input.is_none() {
-                bail!("Input must be supplied when running in non-interactive mode");
-            }
-        }
-
-        let mut stderr = std::io::stderr();
-
-        let args: Vec<String> = std::env::args().collect();
-        if args
-            .iter()
-            .any(|arg| arg == "--profile" || arg.starts_with("--profile="))
-        {
-            execute!(
-                stderr,
-                StyledText::warning_fg(),
-                style::Print("WARNING: "),
-                StyledText::reset(),
-                style::Print("--profile is deprecated, use "),
-                StyledText::success_fg(),
-                style::Print("--agent"),
-                StyledText::reset(),
-                style::Print(" instead\n")
-            )?;
-        }
-
-        let conversation_id = uuid::Uuid::new_v4().to_string();
-        info!(?conversation_id, "Generated new conversation id");
-
-        // Check MCP status once at the beginning of the session
-        let mcp_enabled = match os.client.is_mcp_enabled().await {
-            Ok(enabled) => enabled,
-            Err(err) => {
-                tracing::warn!(?err, "Failed to check MCP configuration, defaulting to enabled");
-                true
-            },
+    pub async fn execute(self, os: &mut Os) -> Result<ExitCode> {
+        use crate::agent_env::{
+            EventBus, Session, AgentEnvironment, WorkerBuilder,
         };
-
-        let agents = {
-            let skip_migration = self.no_interactive;
-            let (mut agents, md) =
-                Agents::load(os, self.agent.as_deref(), skip_migration, &mut stderr, mcp_enabled).await;
-            agents.trust_all_tools = self.trust_all_tools;
-
-            os.telemetry
-                .send_agent_config_init(&os.database, conversation_id.clone(), AgentConfigInitArgs {
-                    agents_loaded_count: md.load_count as i64,
-                    agents_loaded_failed_count: md.load_failed_count as i64,
-                    legacy_profile_migration_executed: md.migration_performed,
-                    legacy_profile_migrated_count: md.migrated_count as i64,
-                    launched_agent: md.launched_agent,
-                })
-                .await
-                .map_err(|err| error!(?err, "failed to send agent config init telemetry"))
-                .ok();
-
-            // Only show MCP safety message if MCP is enabled and has servers
-            if mcp_enabled
-                && agents
-                    .get_active()
-                    .is_some_and(|a| !a.mcp_servers.mcp_servers.is_empty())
-            {
-                if !self.no_interactive && !os.database.settings.get_bool(Setting::McpLoadedBefore).unwrap_or(false) {
-                    execute!(
-                        stderr,
-                        style::Print(
-                            "To learn more about MCP safety, see https://docs.aws.amazon.com/amazonq/latest/qdeveloper-ug/command-line-mcp-security.html\n\n"
-                        )
+        use crate::cli::chat::agent_env_ui::{TextUi, StructuredIO};
+        
+        // Wrap Os in Arc for sharing with WebServer
+        let os_arc = Arc::new(os.clone());
+        
+        // Invert no_interactive flag for clearer logic
+        let interactive = !self.no_interactive;
+        
+        // Initialize time conversion for WebUI events
+        crate::cli::chat::web_server::init_time_conversion();
+        
+        // Task 8.1.1: Create EventBus
+        let event_bus = EventBus::default();
+        
+        // Task 8.1.2: Create Session with EventBus and model providers
+        let platform = self.platform.unwrap_or_default();
+        let model_provider = Self::create_model_provider(platform, os).await?;
+        let model_providers = vec![model_provider];
+        
+        let session = Arc::new(Session::new(event_bus.clone(), model_providers).with_os(os_arc.clone()));
+        
+        // Task 9.3.2: Select UI based on ui_mode and create UI BEFORE worker for StructuredIO
+        let ui_mode = self.ui_mode.unwrap_or(UiMode::Text);
+        
+        // For StructuredIO, create UI before worker so it can receive WorkerEvent::Created
+        let main_ui_structured: Option<Arc<StructuredIO>> = if ui_mode == UiMode::Structured {
+            Some(Arc::new(StructuredIO::new(
+                session.clone(),
+                interactive,
+            )?))
+        } else {
+            None
+        };
+        
+        // Create WebUI if enabled (before worker creation to receive events)
+        let web_ui: Option<Arc<crate::cli::chat::web_server::WebUI>> = if self.web_ui || std::env::var("Q_WEB_UI").is_ok() {
+            use crate::cli::chat::web_server::WebUI;
+            Some(Arc::new(WebUI::new(session.clone())))
+        } else {
+            None
+        };
+        
+        // Collect headless UIs
+        let mut headless_uis: Vec<Arc<dyn crate::agent_env::HeadlessInterface>> = vec![];
+        if let Some(ref web_ui) = web_ui {
+            headless_uis.push(web_ui.clone());
+        }
+        
+        // Create AgentEnvironment with StructuredIO (if present) before worker creation
+        let main_ui_for_agent_env: Option<Arc<dyn crate::agent_env::UserInterface>> = 
+            main_ui_structured.clone().map(|ui| ui as Arc<dyn crate::agent_env::UserInterface>);
+        
+        let agent_env = AgentEnvironment::new(
+            session.clone(),
+            event_bus.clone(),
+            main_ui_for_agent_env,
+            headless_uis,
+            interactive,
+        );
+        
+        // Start event multicasting BEFORE creating worker
+        agent_env.start_event_multicasting();
+        
+        // Task 8.1.3: Create main Worker using WorkerBuilder
+        let main_worker = WorkerBuilder::new()
+            .agent(self.agent.clone())
+            .platform(platform)
+            .model(self.model.clone())
+            .initial_input(self.input.clone())
+            .build(session.clone(), os)
+            .await?;
+        let main_worker_id = main_worker.id;
+        
+        // Create TextUi after worker (TextUi needs worker_id) and update AgentEnvironment if needed
+        let main_ui: Option<Arc<dyn crate::agent_env::UserInterface>> = if main_ui_structured.is_some() {
+            // StructuredIO already set in AgentEnvironment
+            None
+        } else {
+            match ui_mode {
+                UiMode::Text => {
+                    let history_path = directories::chat_cli_bash_history_path(os).ok();
+                    let text_ui = TextUi::new(
+                        session.clone(),
+                        main_worker_id,
+                        history_path,
+                        interactive,
                     )?;
+                    Some(Arc::new(text_ui))
                 }
-                os.database.settings.set(Setting::McpLoadedBefore, true).await?;
-            }
-
-            if let Some(trust_tools) = self.trust_tools.take() {
-                for tool in &trust_tools {
-                    if !tool.starts_with("@") && !NATIVE_TOOLS.contains(&tool.as_str()) {
-                        let _ = queue!(
-                            stderr,
-                            StyledText::warning_fg(),
-                            style::Print("WARNING: "),
-                            StyledText::reset(),
-                            style::Print("--trust-tools arg for custom tool "),
-                            StyledText::brand_fg(),
-                            style::Print(tool),
-                            StyledText::reset(),
-                            style::Print(" needs to be prepended with "),
-                            StyledText::success_fg(),
-                            style::Print("@{MCPSERVERNAME}/"),
-                            StyledText::reset(),
-                            style::Print("\n"),
-                        );
-                    }
-                }
-
-                let _ = stderr.flush();
-
-                if let Some(a) = agents.get_active_mut() {
-                    a.allowed_tools.extend(trust_tools);
+                UiMode::None => {
+                    None // Headless mode
                 }
+                UiMode::Structured => unreachable!("StructuredIO already created"),
             }
-
-            agents
         };
-
-        // If modelId is specified, verify it exists before starting the chat
-        // Otherwise, CLI will use a default model when starting chat
-        let (models, default_model_opt) = get_available_models(os).await?;
-        // Fallback logic: try user's saved default, then system default
-        let fallback_model_id = || {
-            if let Some(saved) = os.database.settings.get_string(Setting::ChatDefaultModel) {
-                find_model(&models, &saved)
-                    .map(|m| m.model_id.clone())
-                    .or(Some(default_model_opt.model_id.clone()))
-            } else {
-                Some(default_model_opt.model_id.clone())
+        
+        // If TextUi was created, we need to recreate AgentEnvironment with it
+        let agent_env = if let Some(text_ui) = main_ui {
+            // Collect headless UIs again
+            let mut headless_uis: Vec<Arc<dyn crate::agent_env::HeadlessInterface>> = vec![];
+            if let Some(ref web_ui) = web_ui {
+                headless_uis.push(web_ui.clone());
             }
+            
+            let new_agent_env = AgentEnvironment::new(
+                session.clone(),
+                event_bus.clone(),
+                Some(text_ui),
+                headless_uis,
+                interactive,
+            );
+            // Start event multicasting for the new AgentEnvironment
+            new_agent_env.start_event_multicasting();
+            new_agent_env
+        } else {
+            agent_env
         };
-
-        let model_id: Option<String> = if let Some(requested) = self.model.as_ref() {
-            // CLI argument takes highest priority
-            if let Some(m) = find_model(&models, requested) {
-                Some(m.model_id.clone())
-            } else {
-                let available = models
-                    .iter()
-                    .map(|m| m.model_name.as_deref().unwrap_or(&m.model_id))
-                    .collect::<Vec<_>>()
-                    .join(", ");
-                bail!("Model '{}' does not exist. Available models: {}", requested, available);
+        
+        // Start web server if WebUI is enabled
+        if let Some(web_ui) = web_ui {
+            use crate::cli::chat::web_server::WebServer;
+            use std::net::SocketAddr;
+            
+            let web_port = self.web_port.unwrap_or(8080);
+            let web_addr: SocketAddr = ([127, 0, 0, 1], web_port).into();
+            
+            let web_server = WebServer::new(
+                web_addr,
+                session.clone(),
+                web_ui,
+                os_arc.clone(),
+            );
+            
+            let shutdown_signal = agent_env.shutdown_signal();
+            tokio::spawn(async move {
+                if let Err(e) = web_server.run_with_shutdown(shutdown_signal).await {
+                    if e.to_string().contains("Address already in use") {
+                        tracing::error!("Port {} already in use. Try --web-port <port>", web_port);
+                    } else {
+                        tracing::error!("Web server error: {}", e);
+                    }
+                }
+            });
+            
+            tracing::info!("Web UI available at http://{}", web_addr);
+        }
+        
+        // Error if no input provided in non-interactive mode
+        if self.input.is_none() && !interactive {
+            return Err(eyre::eyre!("No input provided for non-interactive mode"));
+        }
+        
+        // Spawn job completion monitor before spawning jobs (non-interactive mode only)
+        if !interactive {
+            agent_env.spawn_job_completion_monitor();
+        }
+        
+        // Task 8.1.7: Handle initial prompt if provided
+        if self.input.is_some() {
+            // Initial input was already added to conversation history in Task 8.1.4
+            // Now we need to trigger the agent loop
+            use crate::agent_env::worker_tasks::AgentLoopInput;
+            
+            // Launch agent loop for initial input
+            session.run_task__agent_loop(main_worker.clone(), AgentLoopInput {})?;
+        }
+        
+        // Error if no jobs spawned in non-interactive mode
+        if !interactive && !session.has_active_jobs() {
+            return Err(eyre::eyre!("No jobs spawned in non-interactive mode"));
+        }
+        
+        // Task 8.1.8: Run AgentEnvironment
+        tracing::info!("Starting AgentEnvironment main loop");
+        agent_env.run().await?;
+        tracing::info!("AgentEnvironment main loop exited, returning from execute()");
+        
+        Ok(ExitCode::SUCCESS)
+    }
+    
+    async fn create_model_provider(
+        platform: Platform,
+        os: &mut Os,
+    ) -> Result<Arc<dyn crate::agent_env::ModelProvider>> {
+        use crate::agent_env::model_providers::{BedrockConverseStreamModelProvider, CodeWhispererModelProvider};
+        use crate::api_client::ApiClient;
+        use aws_config::BehaviorVersion;
+        use aws_sdk_bedrockruntime::Client as BedrockClient;
+        use aws_types::region::Region;
+        use eyre::Context;
+        
+        match platform {
+            Platform::Bedrock => {
+                let config = aws_config::defaults(BehaviorVersion::latest())
+                    .region(Region::new("us-east-1"))
+                    .load()
+                    .await;
+                let bedrock_client = BedrockClient::new(&config);
+                Ok(Arc::new(BedrockConverseStreamModelProvider::new(bedrock_client)))
             }
-        } else if let Some(agent_model) = agents.get_active().and_then(|a| a.model.as_ref()) {
-            // Agent model takes second priority
-            if let Some(m) = find_model(&models, agent_model) {
-                Some(m.model_id.clone())
-            } else {
-                let _ = execute!(
-                    stderr,
-                    StyledText::warning_fg(),
-                    style::Print("WARNING: "),
-                    StyledText::reset(),
-                    style::Print("Agent specifies model '"),
-                    StyledText::brand_fg(),
-                    style::Print(agent_model),
-                    StyledText::reset(),
-                    style::Print("' which is not available. Falling back to configured defaults.\n"),
-                );
-                fallback_model_id()
+            Platform::CodeWhisperer => {
+                let api_client = ApiClient::new(
+                    &os.env,
+                    &os.fs,
+                    &mut os.database,
+                    None,  // Use configured endpoint from database
+                ).await
+                    .context("Failed to create CodeWhisperer API client")?;
+                
+                let streaming_client = api_client.streaming_client()
+                    .ok_or_else(|| eyre::eyre!(
+                        "CodeWhisperer streaming client not available. \
+                         Please run 'q login' or check AMAZON_Q_SIGV4 is not set."
+                    ))?;
+                
+                Ok(Arc::new(CodeWhispererModelProvider::new(streaming_client)))
             }
-        } else {
-            fallback_model_id()
-        };
-
-        let (prompt_request_sender, prompt_request_receiver) = tokio::sync::broadcast::channel::<PromptQuery>(5);
-        let (prompt_response_sender, prompt_response_receiver) =
-            tokio::sync::broadcast::channel::<PromptQueryResult>(5);
-        let mut tool_manager = ToolManagerBuilder::default()
-            .prompt_query_result_sender(prompt_response_sender)
-            .prompt_query_receiver(prompt_request_receiver)
-            .prompt_query_sender(prompt_request_sender.clone())
-            .prompt_query_result_receiver(prompt_response_receiver.resubscribe())
-            .conversation_id(&conversation_id)
-            .agent(agents.get_active().cloned().unwrap_or_default())
-            .build(os, Box::new(std::io::stderr()), !self.no_interactive)
-            .await?;
-        let tool_config = tool_manager.load_tools(os, &mut stderr).await?;
-
-        ChatSession::new(
-            os,
-            &conversation_id,
-            agents,
-            input,
-            InputSource::new(os, prompt_request_sender, prompt_response_receiver)?,
-            self.resume,
-            || terminal::window_size().map(|s| s.columns.into()).ok(),
-            tool_manager,
-            model_id,
-            tool_config,
-            !self.no_interactive,
-            mcp_enabled,
-            self.wrap,
-        )
-        .await?
-        .spawn(os)
-        .await
-        .map(|_| ExitCode::SUCCESS)
+        }
     }
 }
 
+// ====  ====  ====  ====  ====  ====  ====  ====  ====  ====  ====  ====  ====
+// =  ====  ORIGINAL ChatSession IMPLEMENTATION ====  ====  ====  ====  ====  =
+// ====  ====  ====  ====  ====  ====  ====  ====  ====  ====  ====  ====  ====
+
 // Maximum number of times to show the changelog announcement per version
 const CHANGELOG_MAX_SHOW_COUNT: i64 = 2;
 
diff --git a/crates/chat-cli/src/cli/chat/web_server/api.rs b/crates/chat-cli/src/cli/chat/web_server/api.rs
new file mode 100644
index 000000000..c8341ea02
--- /dev/null
+++ b/crates/chat-cli/src/cli/chat/web_server/api.rs
@@ -0,0 +1,97 @@
+use axum::{
+    extract::{Path, State},
+    http::StatusCode,
+    response::IntoResponse,
+    Json,
+};
+use serde::Serialize;
+use uuid::Uuid;
+
+use super::server::AppState;
+use super::events::WorkerLifecycleState;
+
+/// Health check endpoint
+pub async fn health_check() -> impl IntoResponse {
+    Json(serde_json::json!({
+        "status": "ok",
+        "version": env!("CARGO_PKG_VERSION"),
+    }))
+}
+
+/// List all workers
+pub async fn list_workers(State(state): State<AppState>) -> impl IntoResponse {
+    let workers = state.session.get_workers();
+    
+    let worker_infos: Vec<WorkerInfo> = workers
+        .iter()
+        .map(|w| {
+            let lifecycle_state = *w.lifecycle_state.lock().unwrap();
+            
+            WorkerInfo {
+                worker_id: w.id.to_string(),
+                name: w.name.clone(),
+                lifecycle_state: lifecycle_state.into(),
+            }
+        })
+        .collect();
+    
+    Json(WorkersResponse {
+        workers: worker_infos,
+    })
+}
+
+/// Get specific worker details
+pub async fn get_worker(
+    Path(worker_id): Path<String>,
+    State(state): State<AppState>,
+) -> Result<impl IntoResponse, (StatusCode, Json<ErrorResponse>)> {
+    let worker_id = Uuid::parse_str(&worker_id).map_err(|_| {
+        (
+            StatusCode::BAD_REQUEST,
+            Json(ErrorResponse {
+                error: "Invalid worker ID".to_string(),
+            }),
+        )
+    })?;
+    
+    let worker = state.session.get_worker(worker_id).ok_or_else(|| {
+        (
+            StatusCode::NOT_FOUND,
+            Json(ErrorResponse {
+                error: "Worker not found".to_string(),
+            }),
+        )
+    })?;
+    
+    let lifecycle_state = *worker.lifecycle_state.lock().unwrap();
+    
+    Ok(Json(WorkerDetailResponse {
+        worker_id: worker.id.to_string(),
+        name: worker.name.clone(),
+        lifecycle_state: lifecycle_state.into(),
+    }))
+}
+
+#[derive(Debug, Serialize)]
+struct WorkersResponse {
+    workers: Vec<WorkerInfo>,
+}
+
+#[derive(Debug, Serialize)]
+struct WorkerInfo {
+    worker_id: String,
+    name: String,
+    lifecycle_state: WorkerLifecycleState,
+}
+
+#[derive(Debug, Serialize)]
+struct WorkerDetailResponse {
+    worker_id: String,
+    name: String,
+    lifecycle_state: WorkerLifecycleState,
+}
+
+#[derive(Debug, Serialize)]
+pub struct ErrorResponse {
+    pub error: String,
+}
diff --git a/crates/chat-cli/src/cli/chat/web_server/events.rs b/crates/chat-cli/src/cli/chat/web_server/events.rs
new file mode 100644
index 000000000..8e4987d33
--- /dev/null
+++ b/crates/chat-cli/src/cli/chat/web_server/events.rs
@@ -0,0 +1,540 @@
+use serde::{Deserialize, Serialize};
+use std::sync::OnceLock;
+use std::time::{Instant, SystemTime, UNIX_EPOCH};
+
+use crate::agent_env::events::{
+    AgentEnvironmentEvent, AgentLoopEvent, JobCompletionResult, JobEvent, OutputChunk,
+    SystemEvent, UserInteractionRequired, WorkerEvent,
+};
+
+use super::serialization::{ConversationEntryJson, WorkerMetadataJson};
+
+// Global state for time conversion (initialized at process start)
+static PROCESS_START_INSTANT: OnceLock<Instant> = OnceLock::new();
+static PROCESS_START_SYSTEM_TIME: OnceLock<SystemTime> = OnceLock::new();
+
+/// Initialize time conversion (call at process start)
+///
+/// This must be called once at application startup to establish the relationship
+/// between Instant (monotonic) and SystemTime (wall clock) for timestamp conversion.
+pub fn init_time_conversion() {
+    PROCESS_START_INSTANT.get_or_init(Instant::now);
+    PROCESS_START_SYSTEM_TIME.get_or_init(SystemTime::now);
+}
+
+/// Convert Instant to Unix timestamp
+///
+/// Note: Instant is monotonic and doesn't have a fixed epoch.
+/// We track the relationship between Instant and SystemTime at process start.
+pub fn instant_to_unix_timestamp(instant: Instant) -> f64 {
+    let start_instant = PROCESS_START_INSTANT
+        .get()
+        .expect("init_time_conversion() must be called at startup");
+    let start_system_time = PROCESS_START_SYSTEM_TIME
+        .get()
+        .expect("init_time_conversion() must be called at startup");
+
+    let elapsed = instant.duration_since(*start_instant);
+    let system_time = *start_system_time + elapsed;
+
+    system_time
+        .duration_since(UNIX_EPOCH)
+        .unwrap()
+        .as_secs_f64()
+}
+
+/// Worker lifecycle state (serializable)
+#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum WorkerLifecycleState {
+    Idle,
+    Busy,
+    IdleFailed,
+}
+
+impl From<crate::agent_env::events::WorkerLifecycleState> for WorkerLifecycleState {
+    fn from(state: crate::agent_env::events::WorkerLifecycleState) -> Self {
+        match state {
+            crate::agent_env::events::WorkerLifecycleState::Idle => Self::Idle,
+            crate::agent_env::events::WorkerLifecycleState::Busy => Self::Busy,
+            crate::agent_env::events::WorkerLifecycleState::IdleFailed => Self::IdleFailed,
+        }
+    }
+}
+
+/// Job completion result (serializable)
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(tag = "status", rename_all = "snake_case")]
+pub enum JobResult {
+    Success {
+        #[serde(skip_serializing_if = "Option::is_none")]
+        task_metadata: Option<serde_json::Value>,
+        user_interaction_required: bool,
+    },
+    Cancelled,
+    Failed {
+        error: String,
+    },
+}
+
+impl From<JobCompletionResult> for JobResult {
+    fn from(result: JobCompletionResult) -> Self {
+        match result {
+            JobCompletionResult::Success {
+                task_metadata,
+                user_interaction_required,
+            } => Self::Success {
+                task_metadata: if task_metadata.is_empty() {
+                    None
+                } else {
+                    Some(serde_json::to_value(task_metadata).unwrap_or(serde_json::Value::Null))
+                },
+                user_interaction_required: matches!(
+                    user_interaction_required,
+                    UserInteractionRequired::ToolApproval
+                ),
+            },
+            JobCompletionResult::Cancelled => Self::Cancelled,
+            JobCompletionResult::Failed { error } => Self::Failed { error },
+        }
+    }
+}
+
+/// Output chunk data (serializable)
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(tag = "chunk_type", rename_all = "snake_case")]
+pub enum OutputChunkData {
+    AssistantResponse { text: String },
+    ToolUse {
+        tool_name: String,
+        tool_input: serde_json::Value,
+    },
+    ToolResult {
+        tool_name: String,
+        result: String,
+    },
+}
+
+impl From<OutputChunk> for OutputChunkData {
+    fn from(chunk: OutputChunk) -> Self {
+        match chunk {
+            OutputChunk::AssistantResponse(text) => Self::AssistantResponse { text },
+            OutputChunk::ToolUse {
+                tool_name,
+                tool_input,
+            } => Self::ToolUse {
+                tool_name,
+                tool_input,
+            },
+            OutputChunk::ToolResult { tool_name, result } => Self::ToolResult { tool_name, result },
+        }
+    }
+}
+
+/// Serializable events for WebUI
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(tag = "type", rename_all = "snake_case")]
+pub enum WebUIEvent {
+    // Worker Events
+    WorkerCreated {
+        worker_id: String,
+        name: String,
+        timestamp: f64,
+    },
+    WorkerDeleted {
+        worker_id: String,
+        timestamp: f64,
+    },
+    WorkerStateChanged {
+        worker_id: String,
+        old_state: WorkerLifecycleState,
+        new_state: WorkerLifecycleState,
+        timestamp: f64,
+    },
+
+    // Job Events
+    JobStarted {
+        worker_id: String,
+        job_id: String,
+        task_type: String,
+        timestamp: f64,
+    },
+    JobCompleted {
+        worker_id: String,
+        job_id: String,
+        result: JobResult,
+        timestamp: f64,
+    },
+    OutputChunk {
+        worker_id: String,
+        job_id: String,
+        chunk: OutputChunkData,
+        timestamp: f64,
+    },
+
+    // AgentLoop Events
+    ResponseReceived {
+        worker_id: String,
+        job_id: String,
+        text: String,
+        timestamp: f64,
+    },
+    ToolUseRequested {
+        worker_id: String,
+        job_id: String,
+        tool_name: String,
+        tool_input: serde_json::Value,
+        timestamp: f64,
+    },
+
+    // System Events
+    ShutdownInitiated {
+        reason: String,
+        timestamp: f64,
+    },
+
+    // WebUI Events
+    PromptReceived {
+        worker_id: String,
+        text: String,
+        timestamp: f64,
+    },
+    ServerStarted {
+        address: String,
+        timestamp: f64,
+    },
+    WebSocketConnected {
+        timestamp: f64,
+    },
+
+    // Snapshot Events (for initial state sync and queries)
+    WorkersSnapshot {
+        workers: Vec<WorkerMetadataJson>,
+        timestamp: f64,
+    },
+    ConversationSnapshot {
+        worker_id: String,
+        entries: Vec<ConversationEntryJson>,
+        timestamp: f64,
+    },
+
+    // Error Events
+    Error {
+        command: String,
+        message: String,
+        timestamp: f64,
+    },
+}
+
+impl WebUIEvent {
+    /// Convert AgentEnvironmentEvent to WebUIEvent
+    pub fn from_agent_event(event: AgentEnvironmentEvent) -> Self {
+        match event {
+            AgentEnvironmentEvent::Worker(worker_event) => Self::from_worker_event(worker_event),
+            AgentEnvironmentEvent::Job(job_event) => Self::from_job_event(job_event),
+            AgentEnvironmentEvent::AgentLoop(agent_loop_event) => {
+                Self::from_agent_loop_event(agent_loop_event)
+            }
+            AgentEnvironmentEvent::System(system_event) => {
+                Self::from_system_event(system_event)
+            }
+            AgentEnvironmentEvent::WebUI(webui_event) => {
+                Self::from_webui_event(webui_event)
+            }
+        }
+    }
+
+    fn from_worker_event(event: WorkerEvent) -> Self {
+        match event {
+            WorkerEvent::Created {
+                worker_id,
+                name,
+                timestamp,
+            } => WebUIEvent::WorkerCreated {
+                worker_id: worker_id.to_string(),
+                name,
+                timestamp: instant_to_unix_timestamp(timestamp),
+            },
+            WorkerEvent::Deleted {
+                worker_id,
+                timestamp,
+            } => WebUIEvent::WorkerDeleted {
+                worker_id: worker_id.to_string(),
+                timestamp: instant_to_unix_timestamp(timestamp),
+            },
+            WorkerEvent::LifecycleStateChanged {
+                worker_id,
+                old_state,
+                new_state,
+                timestamp,
+            } => WebUIEvent::WorkerStateChanged {
+                worker_id: worker_id.to_string(),
+                old_state: old_state.into(),
+                new_state: new_state.into(),
+                timestamp: instant_to_unix_timestamp(timestamp),
+            },
+        }
+    }
+
+    fn from_job_event(event: JobEvent) -> Self {
+        match event {
+            JobEvent::Started {
+                worker_id,
+                job_id,
+                task_type,
+                timestamp,
+            } => WebUIEvent::JobStarted {
+                worker_id: worker_id.to_string(),
+                job_id: job_id.to_string(),
+                task_type,
+                timestamp: instant_to_unix_timestamp(timestamp),
+            },
+            JobEvent::Completed {
+                worker_id,
+                job_id,
+                result,
+                timestamp,
+            } => WebUIEvent::JobCompleted {
+                worker_id: worker_id.to_string(),
+                job_id: job_id.to_string(),
+                result: result.into(),
+                timestamp: instant_to_unix_timestamp(timestamp),
+            },
+            JobEvent::OutputChunk {
+                worker_id,
+                job_id,
+                chunk,
+                timestamp,
+            } => WebUIEvent::OutputChunk {
+                worker_id: worker_id.to_string(),
+                job_id: job_id.to_string(),
+                chunk: chunk.into(),
+                timestamp: instant_to_unix_timestamp(timestamp),
+            },
+        }
+    }
+
+    fn from_agent_loop_event(event: AgentLoopEvent) -> Self {
+        match event {
+            AgentLoopEvent::ResponseReceived {
+                worker_id,
+                job_id,
+                text,
+                timestamp,
+            } => WebUIEvent::ResponseReceived {
+                worker_id: worker_id.to_string(),
+                job_id: job_id.to_string(),
+                text,
+                timestamp: instant_to_unix_timestamp(timestamp),
+            },
+            AgentLoopEvent::ToolUseRequestReceived {
+                worker_id,
+                job_id,
+                tool_name,
+                tool_input,
+                timestamp,
+            } => WebUIEvent::ToolUseRequested {
+                worker_id: worker_id.to_string(),
+                job_id: job_id.to_string(),
+                tool_name,
+                tool_input,
+                timestamp: instant_to_unix_timestamp(timestamp),
+            },
+        }
+    }
+
+    fn from_system_event(event: SystemEvent) -> Self {
+        match event {
+            SystemEvent::ShutdownInitiated { reason, timestamp } => {
+                WebUIEvent::ShutdownInitiated {
+                    reason,
+                    timestamp: instant_to_unix_timestamp(timestamp),
+                }
+            }
+        }
+    }
+
+    fn from_webui_event(event: crate::agent_env::events::WebUIEvent) -> Self {
+        match event {
+            crate::agent_env::events::WebUIEvent::PromptReceived {
+                worker_id,
+                text,
+                timestamp,
+            } => WebUIEvent::PromptReceived {
+                worker_id: worker_id.to_string(),
+                text,
+                timestamp: instant_to_unix_timestamp(timestamp),
+            },
+            crate::agent_env::events::WebUIEvent::ServerStarted {
+                address,
+                timestamp,
+            } => WebUIEvent::ServerStarted {
+                address,
+                timestamp: instant_to_unix_timestamp(timestamp),
+            },
+            crate::agent_env::events::WebUIEvent::WebSocketConnected {
+                timestamp,
+            } => WebUIEvent::WebSocketConnected {
+                timestamp: instant_to_unix_timestamp(timestamp),
+            },
+        }
+    }
+
+    /// Extract worker_id from events that have one
+    pub fn worker_id(&self) -> Option<&str> {
+        match self {
+            Self::WorkerCreated { worker_id, .. }
+            | Self::WorkerDeleted { worker_id, .. }
+            | Self::WorkerStateChanged { worker_id, .. }
+            | Self::JobStarted { worker_id, .. }
+            | Self::JobCompleted { worker_id, .. }
+            | Self::OutputChunk { worker_id, .. }
+            | Self::ResponseReceived { worker_id, .. }
+            | Self::ToolUseRequested { worker_id, .. }
+            | Self::PromptReceived { worker_id, .. }
+            | Self::ConversationSnapshot { worker_id, .. } => Some(worker_id),
+            Self::ShutdownInitiated { .. }
+            | Self::ServerStarted { .. }
+            | Self::WebSocketConnected { .. }
+            | Self::WorkersSnapshot { .. }
+            | Self::Error { .. } => None,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use uuid::Uuid;
+
+    #[test]
+    fn test_time_conversion_initialization() {
+        init_time_conversion();
+        assert!(PROCESS_START_INSTANT.get().is_some());
+        assert!(PROCESS_START_SYSTEM_TIME.get().is_some());
+    }
+
+    #[test]
+    fn test_instant_to_unix_timestamp() {
+        init_time_conversion();
+        let now = Instant::now();
+        let timestamp = instant_to_unix_timestamp(now);
+
+        // Timestamp should be reasonable (not negative, not far future)
+        assert!(timestamp > 1_600_000_000.0); // After 2020
+        assert!(timestamp < 2_000_000_000.0); // Before 2033
+    }
+
+    #[test]
+    fn test_worker_lifecycle_state_conversion() {
+        let idle: WorkerLifecycleState =
+            crate::agent_env::events::WorkerLifecycleState::Idle.into();
+        assert!(matches!(idle, WorkerLifecycleState::Idle));
+
+        let busy: WorkerLifecycleState =
+            crate::agent_env::events::WorkerLifecycleState::Busy.into();
+        assert!(matches!(busy, WorkerLifecycleState::Busy));
+
+        let failed: WorkerLifecycleState =
+            crate::agent_env::events::WorkerLifecycleState::IdleFailed.into();
+        assert!(matches!(failed, WorkerLifecycleState::IdleFailed));
+    }
+
+    #[test]
+    fn test_worker_created_event_conversion() {
+        init_time_conversion();
+
+        let worker_id = Uuid::new_v4();
+        let timestamp = Instant::now();
+
+        let internal_event = AgentEnvironmentEvent::Worker(WorkerEvent::Created {
+            worker_id,
+            name: "test-worker".to_string(),
+            timestamp,
+        });
+
+        let web_event = WebUIEvent::from_agent_event(internal_event);
+
+        match web_event {
+            WebUIEvent::WorkerCreated {
+                worker_id: id,
+                name,
+                timestamp: ts,
+            } => {
+                assert_eq!(id, worker_id.to_string());
+                assert_eq!(name, "test-worker");
+                assert!(ts > 0.0);
+            }
+            _ => panic!("Expected WorkerCreated event"),
+        }
+    }
+
+    #[test]
+    fn test_job_started_event_conversion() {
+        init_time_conversion();
+
+        let worker_id = Uuid::new_v4();
+        let job_id = Uuid::new_v4();
+        let timestamp = Instant::now();
+
+        let internal_event = AgentEnvironmentEvent::Job(JobEvent::Started {
+            worker_id,
+            job_id,
+            task_type: "agent_loop".to_string(),
+            timestamp,
+        });
+
+        let web_event = WebUIEvent::from_agent_event(internal_event);
+
+        match web_event {
+            WebUIEvent::JobStarted {
+                worker_id: wid,
+                job_id: jid,
+                task_type,
+                ..
+            } => {
+                assert_eq!(wid, worker_id.to_string());
+                assert_eq!(jid, job_id.to_string());
+                assert_eq!(task_type, "agent_loop");
+            }
+            _ => panic!("Expected JobStarted event"),
+        }
+    }
+
+    #[test]
+    fn test_output_chunk_conversion() {
+        let chunk = OutputChunk::AssistantResponse("Hello!".to_string());
+        let data: OutputChunkData = chunk.into();
+
+        match data {
+            OutputChunkData::AssistantResponse { text } => {
+                assert_eq!(text, "Hello!");
+            }
+            _ => panic!("Expected AssistantResponse"),
+        }
+    }
+
+    #[test]
+    fn test_worker_id_extraction() {
+        init_time_conversion();
+
+        let worker_id = Uuid::new_v4();
+        let timestamp = Instant::now();
+
+        let event = WebUIEvent::from_agent_event(AgentEnvironmentEvent::Worker(
+            WorkerEvent::Created {
+                worker_id,
+                name: "test".to_string(),
+                timestamp,
+            },
+        ));
+
+        assert_eq!(event.worker_id(), Some(worker_id.to_string().as_str()));
+
+        let event = WebUIEvent::ShutdownInitiated {
+            reason: "test".to_string(),
+            timestamp: 0.0,
+        };
+        assert_eq!(event.worker_id(), None);
+    }
+}
diff --git a/crates/chat-cli/src/cli/chat/web_server/mod.rs b/crates/chat-cli/src/cli/chat/web_server/mod.rs
new file mode 100644
index 000000000..c4809c3e8
--- /dev/null
+++ b/crates/chat-cli/src/cli/chat/web_server/mod.rs
@@ -0,0 +1,10 @@
+mod api;
+mod events;
+mod serialization;
+mod server;
+mod web_ui;
+mod websocket;
+
+pub use events::{init_time_conversion, WebUIEvent};
+pub use server::{AppState, WebServer};
+pub use web_ui::WebUI;
diff --git a/crates/chat-cli/src/cli/chat/web_server/serialization.rs b/crates/chat-cli/src/cli/chat/web_server/serialization.rs
new file mode 100644
index 000000000..ec1bb83ff
--- /dev/null
+++ b/crates/chat-cli/src/cli/chat/web_server/serialization.rs
@@ -0,0 +1,143 @@
+//! Conversation and worker metadata serialization for WebUI
+//!
+//! This module provides simplified JSON types for conversation history and worker metadata,
+//! along with conversion functions from internal types.
+
+use serde::{Deserialize, Serialize};
+use std::time::{SystemTime, UNIX_EPOCH};
+
+use crate::agent_env::{
+    context_container::ConversationEntry,
+    events::WorkerLifecycleState,
+    worker::Worker,
+};
+use crate::cli::chat::{AssistantMessage, AssistantToolUse, UserMessage};
+use crate::cli::chat::message::UserMessageContent;
+
+/// Get current Unix timestamp
+pub fn current_unix_timestamp() -> f64 {
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap()
+        .as_secs_f64()
+}
+
+/// Tool use information for JSON serialization
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ToolUseJson {
+    pub tool_name: String,
+    pub tool_input: serde_json::Value,
+}
+
+/// Conversation entry for JSON serialization
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(tag = "type", rename_all = "snake_case")]
+pub enum ConversationEntryJson {
+    UserMessage {
+        content: String,
+        timestamp: f64,
+    },
+    AssistantMessage {
+        content: String,
+        timestamp: f64,
+    },
+    ToolUse {
+        content: String,
+        tool_uses: Vec<ToolUseJson>,
+        timestamp: f64,
+    },
+}
+
+/// Worker metadata for JSON serialization
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct WorkerMetadataJson {
+    pub id: String,
+    pub name: String,
+    pub agent: String,
+    pub state: WorkerLifecycleState,
+}
+
+/// Convert ConversationEntry to ConversationEntryJson
+pub fn convert_conversation_entry(entry: &ConversationEntry) -> ConversationEntryJson {
+    // Try user message first
+    if let Some(user_msg) = &entry.user {
+        let content = extract_user_content(user_msg);
+        let timestamp = user_msg
+            .timestamp
+            .as_ref()
+            .map(|dt| dt.timestamp() as f64)
+            .unwrap_or_else(current_unix_timestamp);
+        
+        return ConversationEntryJson::UserMessage { content, timestamp };
+    }
+
+    // Try assistant message
+    if let Some(assistant_msg) = &entry.assistant {
+        match assistant_msg {
+            AssistantMessage::Response { content, .. } => {
+                let timestamp = current_unix_timestamp(); // Approximate
+                return ConversationEntryJson::AssistantMessage { 
+                    content: content.clone(), 
+                    timestamp 
+                };
+            }
+            AssistantMessage::ToolUse { tool_uses, .. } => {
+                let content = format!("Using {} tool(s)", tool_uses.len());
+                let tool_uses_json = tool_uses.iter().map(convert_tool_use).collect();
+                let timestamp = current_unix_timestamp(); // Approximate
+                return ConversationEntryJson::ToolUse {
+                    content,
+                    tool_uses: tool_uses_json,
+                    timestamp,
+                };
+            }
+        }
+    }
+
+    // Empty entry (shouldn't happen, but be defensive)
+    ConversationEntryJson::UserMessage {
+        content: String::new(),
+        timestamp: current_unix_timestamp(),
+    }
+}
+
+/// Extract user message content as string
+fn extract_user_content(user_msg: &UserMessage) -> String {
+    match &user_msg.content {
+        UserMessageContent::Prompt { prompt } => prompt.clone(),
+        UserMessageContent::CancelledToolUses { prompt, .. } => {
+            prompt.clone().unwrap_or_else(|| "[Cancelled]".to_string())
+        }
+        UserMessageContent::ToolUseResults { .. } => "[Tool Results]".to_string(),
+    }
+}
+
+/// Convert AssistantToolUse to ToolUseJson
+fn convert_tool_use(tool_use: &AssistantToolUse) -> ToolUseJson {
+    ToolUseJson {
+        tool_name: tool_use.name.clone(),
+        tool_input: tool_use.args.clone(),
+    }
+}
+
+/// Convert Worker to WorkerMetadataJson
+pub fn convert_worker_metadata(worker: &Worker) -> WorkerMetadataJson {
+    let state = *worker.lifecycle_state.lock().unwrap();
+    
+    // Get agent name from task_metadata, default to "default" if not set
+    let agent = worker
+        .task_metadata
+        .lock()
+        .unwrap()
+        .get("agent")
+        .and_then(|v| v.as_str())
+        .unwrap_or("default")
+        .to_string();
+
+    WorkerMetadataJson {
+        id: worker.id.to_string(),
+        name: worker.name.clone(),
+        agent,
+        state,
+    }
+}
diff --git a/crates/chat-cli/src/cli/chat/web_server/server.rs b/crates/chat-cli/src/cli/chat/web_server/server.rs
new file mode 100644
index 000000000..d2d267dfb
--- /dev/null
+++ b/crates/chat-cli/src/cli/chat/web_server/server.rs
@@ -0,0 +1,98 @@
+use axum::{routing::get, Router};
+use eyre::Result;
+use std::net::SocketAddr;
+use std::sync::Arc;
+use tokio::sync::Notify;
+use tower_http::cors::{Any, CorsLayer};
+use tower_http::services::ServeDir;
+
+use crate::agent_env::session::Session;
+use crate::os::Os;
+
+use super::web_ui::WebUI;
+
+/// Application state shared across handlers
+#[derive(Clone)]
+pub struct AppState {
+    pub session: Arc<Session>,
+    pub web_ui: Arc<WebUI>,
+    pub os: Arc<Os>,
+}
+
+/// Web server for serving WebUI
+pub struct WebServer {
+    addr: SocketAddr,
+    state: AppState,
+}
+
+impl WebServer {
+    /// Create new web server
+    pub fn new(addr: SocketAddr, session: Arc<Session>, web_ui: Arc<WebUI>, os: Arc<Os>) -> Self {
+        Self {
+            addr,
+            state: AppState { session, web_ui, os },
+        }
+    }
+
+    /// Build router with all routes
+    fn build_router(&self) -> Router {
+        Router::new()
+            // WebSocket endpoint (global, not per-worker)
+            .route("/ws", get(super::websocket::websocket_handler))
+            // REST API endpoints
+            .route("/api/health", get(super::api::health_check))
+            .route("/api/workers", get(super::api::list_workers))
+            .route("/api/workers/:id", get(super::api::get_worker))
+            // Static file serving (frontend)
+            .nest_service("/", ServeDir::new("web/public"))
+            // CORS for development
+            .layer(CorsLayer::new().allow_origin(Any).allow_methods(Any).allow_headers(Any))
+            // Shared state
+            .with_state(self.state.clone())
+    }
+
+    /// Run the web server (blocks until shutdown)
+    pub async fn run(self) -> Result<()> {
+        let router = self.build_router();
+
+        tracing::info!("Web server listening on http://{}", self.addr);
+
+        let listener = tokio::net::TcpListener::bind(self.addr).await?;
+
+        axum::serve(listener, router).await?;
+
+        Ok(())
+    }
+
+    /// Run with graceful shutdown signal
+    pub async fn run_with_shutdown(self, shutdown_signal: Arc<Notify>) -> Result<()> {
+        let router = self.build_router();
+
+        let listener = tokio::net::TcpListener::bind(self.addr).await?;
+        
+        let address = format!("http://{}", self.addr);
+        tracing::info!("Web server listening on {}", address);
+        
+        // Publish ServerStarted event
+        self.state.session.event_bus().publish(
+            crate::agent_env::AgentEnvironmentEvent::WebUI(
+                crate::agent_env::events::WebUIEvent::ServerStarted {
+                    address,
+                    timestamp: std::time::Instant::now(),
+                }
+            )
+        );
+
+        axum::serve(listener, router)
+            .with_graceful_shutdown(async move {
+                shutdown_signal.notified().await;
+                tracing::info!("Web server shutting down");
+
+                // Give connections 5 seconds to close
+                tokio::time::sleep(tokio::time::Duration::from_secs(5)).await;
+            })
+            .await?;
+
+        Ok(())
+    }
+}
diff --git a/crates/chat-cli/src/cli/chat/web_server/web_ui.rs b/crates/chat-cli/src/cli/chat/web_server/web_ui.rs
new file mode 100644
index 000000000..6e0b7b349
--- /dev/null
+++ b/crates/chat-cli/src/cli/chat/web_server/web_ui.rs
@@ -0,0 +1,170 @@
+use async_trait::async_trait;
+use std::sync::Arc;
+use tokio::sync::broadcast;
+
+use crate::agent_env::{
+    agent_environment::HeadlessInterface, events::AgentEnvironmentEvent, session::Session,
+};
+
+use super::events::WebUIEvent;
+
+/// WebUI component for broadcasting events to WebSocket clients
+pub struct WebUI {
+    session: Arc<Session>,
+    event_tx: broadcast::Sender<WebUIEvent>,
+}
+
+impl WebUI {
+    /// Create new WebUI
+    pub fn new(session: Arc<Session>) -> Self {
+        // Large buffer to handle bursts of events
+        let (event_tx, _) = broadcast::channel(10000);
+
+        Self { session, event_tx }
+    }
+
+    /// Subscribe to WebUI events (for WebSocket handlers)
+    pub fn subscribe(&self) -> broadcast::Receiver<WebUIEvent> {
+        self.event_tx.subscribe()
+    }
+
+    /// Get session reference
+    pub fn session(&self) -> &Arc<Session> {
+        &self.session
+    }
+}
+
+#[async_trait]
+impl HeadlessInterface for WebUI {
+    async fn handle_event(&self, event: AgentEnvironmentEvent) {
+        // Convert to WebUIEvent
+        let web_event = WebUIEvent::from_agent_event(event);
+
+        // Broadcast to all subscribers (WebSocket handlers)
+        // Ignore send errors (no subscribers is OK)
+        let _ = self.event_tx.send(web_event);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::agent_env::{
+        event_bus::EventBus,
+        events::{SystemEvent, WorkerEvent},
+    };
+    use std::time::Instant;
+    use uuid::Uuid;
+
+    fn create_test_session() -> Arc<Session> {
+        let event_bus = EventBus::default();
+        Arc::new(Session::new(event_bus, vec![]))
+    }
+
+    #[test]
+    fn test_web_ui_new() {
+        let session = create_test_session();
+        let web_ui = WebUI::new(session.clone());
+
+        assert!(Arc::ptr_eq(&web_ui.session, &session));
+    }
+
+    #[test]
+    fn test_web_ui_subscribe() {
+        let session = create_test_session();
+        let web_ui = WebUI::new(session);
+
+        let _rx1 = web_ui.subscribe();
+        let _rx2 = web_ui.subscribe();
+
+        // Multiple subscriptions should work
+    }
+
+    #[test]
+    fn test_web_ui_session_access() {
+        let session = create_test_session();
+        let web_ui = WebUI::new(session.clone());
+
+        let session_ref = web_ui.session();
+        assert!(Arc::ptr_eq(session_ref, &session));
+    }
+
+    #[tokio::test]
+    async fn test_web_ui_handle_event_broadcasts() {
+        // Initialize time conversion for tests
+        super::super::events::init_time_conversion();
+
+        let session = create_test_session();
+        let web_ui = WebUI::new(session);
+
+        let mut rx = web_ui.subscribe();
+
+        let event = AgentEnvironmentEvent::Worker(WorkerEvent::Created {
+            worker_id: Uuid::new_v4(),
+            name: "test".to_string(),
+            timestamp: Instant::now(),
+        });
+
+        web_ui.handle_event(event).await;
+
+        let received = rx.recv().await.unwrap();
+        match received {
+            WebUIEvent::WorkerCreated { name, .. } => {
+                assert_eq!(name, "test");
+            }
+            _ => panic!("Expected WorkerCreated event"),
+        }
+    }
+
+    #[tokio::test]
+    async fn test_web_ui_multiple_subscribers() {
+        // Initialize time conversion for tests
+        super::super::events::init_time_conversion();
+
+        let session = create_test_session();
+        let web_ui = WebUI::new(session);
+
+        let mut rx1 = web_ui.subscribe();
+        let mut rx2 = web_ui.subscribe();
+
+        let event = AgentEnvironmentEvent::System(SystemEvent::ShutdownInitiated {
+            reason: "test".to_string(),
+            timestamp: Instant::now(),
+        });
+
+        web_ui.handle_event(event).await;
+
+        // Both subscribers should receive the event
+        let received1 = rx1.recv().await.unwrap();
+        let received2 = rx2.recv().await.unwrap();
+
+        match (received1, received2) {
+            (
+                WebUIEvent::ShutdownInitiated { reason: r1, .. },
+                WebUIEvent::ShutdownInitiated { reason: r2, .. },
+            ) => {
+                assert_eq!(r1, "test");
+                assert_eq!(r2, "test");
+            }
+            _ => panic!("Expected ShutdownInitiated events"),
+        }
+    }
+
+    #[tokio::test]
+    async fn test_web_ui_no_subscribers_ok() {
+        // Initialize time conversion for tests
+        super::super::events::init_time_conversion();
+
+        let session = create_test_session();
+        let web_ui = WebUI::new(session);
+
+        // No subscribers, should not panic
+        let event = AgentEnvironmentEvent::System(SystemEvent::ShutdownInitiated {
+            reason: "test".to_string(),
+            timestamp: Instant::now(),
+        });
+
+        web_ui.handle_event(event).await;
+        // Success if no panic
+    }
+}
diff --git a/crates/chat-cli/src/cli/chat/web_server/websocket.rs b/crates/chat-cli/src/cli/chat/web_server/websocket.rs
new file mode 100644
index 000000000..c9fed05f7
--- /dev/null
+++ b/crates/chat-cli/src/cli/chat/web_server/websocket.rs
@@ -0,0 +1,552 @@
+use axum::{
+    extract::{
+        ws::{Message, WebSocket},
+        Path, State, WebSocketUpgrade,
+    },
+    response::IntoResponse,
+};
+use eyre::Result;
+use futures::{SinkExt, StreamExt};
+use serde::{Deserialize, Serialize};
+use std::sync::Arc;
+use std::time::{SystemTime, UNIX_EPOCH};
+use uuid::Uuid;
+
+use crate::agent_env::session::Session;
+
+use super::{
+    api::ErrorResponse,
+    events::{instant_to_unix_timestamp, WebUIEvent, WorkerLifecycleState as WebWorkerLifecycleState},
+    AppState,
+};
+
+/// Commands sent from frontend to backend via WebSocket
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(tag = "type", rename_all = "snake_case")]
+pub enum WebSocketCommand {
+    /// Send a prompt to the worker
+    Prompt {
+        worker_id: String,
+        text: String,
+    },
+    /// Cancel the current job
+    Cancel {
+        worker_id: String,
+    },
+    /// Create a new worker
+    CreateWorker {
+        name: Option<String>,
+        agent: String,
+        working_directory: Option<String>,
+    },
+    /// Get all workers
+    GetWorkers,
+    /// Get conversation history for a worker
+    GetConversationHistory {
+        worker_id: String,
+    },
+    /// Ping to keep connection alive
+    Ping,
+}
+
+impl WebSocketCommand {
+    /// Validate the command
+    pub fn validate(&self) -> Result<(), String> {
+        match self {
+            WebSocketCommand::Prompt { worker_id, text } => {
+                if worker_id.trim().is_empty() {
+                    return Err("Worker ID cannot be empty".to_string());
+                }
+                if text.trim().is_empty() {
+                    return Err("Prompt text cannot be empty".to_string());
+                }
+                Ok(())
+            }
+            WebSocketCommand::Cancel { worker_id } => {
+                if worker_id.trim().is_empty() {
+                    return Err("Worker ID cannot be empty".to_string());
+                }
+                Ok(())
+            }
+            WebSocketCommand::CreateWorker { agent, .. } => {
+                if agent.trim().is_empty() {
+                    return Err("Agent name cannot be empty".to_string());
+                }
+                Ok(())
+            }
+            WebSocketCommand::GetWorkers => Ok(()),
+            WebSocketCommand::GetConversationHistory { worker_id } => {
+                if worker_id.trim().is_empty() {
+                    return Err("Worker ID cannot be empty".to_string());
+                }
+                Ok(())
+            }
+            WebSocketCommand::Ping => Ok(()),
+        }
+    }
+}
+
+/// WebSocket upgrade handler
+pub async fn websocket_handler(
+    State(state): State<AppState>,
+    ws: WebSocketUpgrade,
+) -> impl IntoResponse {
+    // Upgrade to WebSocket (no worker validation needed)
+    ws.on_upgrade(move |socket| handle_websocket(socket, state))
+        .into_response()
+}
+
+/// Handle WebSocket connection
+async fn handle_websocket(socket: WebSocket, state: AppState) {
+    let (mut sender, mut receiver) = socket.split();
+
+    // Publish WebSocketConnected event
+    state.session.event_bus().publish(
+        crate::agent_env::AgentEnvironmentEvent::WebUI(
+            crate::agent_env::events::WebUIEvent::WebSocketConnected {
+                timestamp: std::time::Instant::now(),
+            }
+        )
+    );
+
+    // Subscribe to events BEFORE sending snapshot to prevent race condition
+    let mut event_rx = state.web_ui.subscribe();
+
+    // Create channel for command responses
+    let (response_tx, mut response_rx) = tokio::sync::mpsc::unbounded_channel::<WebUIEvent>();
+
+    // Send initial snapshots (WorkersSnapshot, ConversationSnapshot for main worker)
+    if let Err(e) = send_initial_snapshots(&mut sender, &state).await {
+        tracing::error!("Failed to send initial snapshots: {}", e);
+        return;
+    }
+
+    tracing::info!("WebSocket connected (global connection)");
+
+    // Spawn task to forward events and responses to WebSocket
+    let send_task = {
+        tokio::spawn(async move {
+            loop {
+                tokio::select! {
+                    // Forward events from EventBus
+                    event_result = event_rx.recv() => {
+                        match event_result {
+                            Ok(event) => {
+                                // Send ALL events (no filtering by worker_id)
+                                // Frontend will handle routing to appropriate UI components
+
+                                // Serialize to JSON
+                                let json = match serde_json::to_string(&event) {
+                                    Ok(json) => json,
+                                    Err(e) => {
+                                        tracing::error!("Failed to serialize event: {}", e);
+                                        continue;
+                                    }
+                                };
+
+                                // Send to WebSocket
+                                if sender.send(Message::Text(json)).await.is_err() {
+                                    break;
+                                }
+                            }
+                            Err(tokio::sync::broadcast::error::RecvError::Lagged(n)) => {
+                                tracing::warn!("WebSocket lagged by {} events", n);
+                                // Could send fresh snapshot here, but for MVP just log
+                            }
+                            Err(tokio::sync::broadcast::error::RecvError::Closed) => {
+                                break;
+                            }
+                        }
+                    }
+                    // Forward command responses
+                    Some(response) = response_rx.recv() => {
+                        let json = match serde_json::to_string(&response) {
+                            Ok(json) => json,
+                            Err(e) => {
+                                tracing::error!("Failed to serialize response: {}", e);
+                                continue;
+                            }
+                        };
+
+                        if sender.send(Message::Text(json)).await.is_err() {
+                            break;
+                        }
+                    }
+                }
+            }
+        })
+    };
+
+    // Spawn task to handle incoming commands
+    let session = state.session.clone();
+    let recv_task = tokio::spawn(async move {
+        while let Some(Ok(msg)) = receiver.next().await {
+            if let Message::Text(text) = msg {
+                if let Err(e) = handle_command(&text, &session, &response_tx).await {
+                    tracing::error!("Failed to handle command: {}", e);
+                }
+            }
+        }
+    });
+
+    // Wait for either task to complete
+    tokio::select! {
+        _ = send_task => {
+            tracing::info!("WebSocket send task completed");
+        }
+        _ = recv_task => {
+            tracing::info!("WebSocket receive task completed");
+        }
+    }
+}
+
+
+/// Handle incoming command
+async fn handle_command(
+    text: &str,
+    session: &Arc<Session>,
+    response_tx: &tokio::sync::mpsc::UnboundedSender<WebUIEvent>,
+) -> Result<()> {
+    let command: WebSocketCommand = serde_json::from_str(text)?;
+
+    // Validate command
+    if let Err(e) = command.validate() {
+        tracing::warn!("Invalid command: {}", e);
+        return Ok(()); // Don't fail, just log
+    }
+
+    match command {
+        WebSocketCommand::Prompt { worker_id, text } => {
+            // Parse worker_id
+            let worker_uuid = match Uuid::parse_str(&worker_id) {
+                Ok(uuid) => uuid,
+                Err(_) => {
+                    tracing::error!("Invalid worker ID format: {}", worker_id);
+                    let error_event = WebUIEvent::Error {
+                        command: "prompt".to_string(),
+                        message: "Invalid worker ID format".to_string(),
+                        timestamp: super::serialization::current_unix_timestamp(),
+                    };
+                    let _ = response_tx.send(error_event);
+                    return Ok(());
+                }
+            };
+
+            // Get worker
+            let worker = match session.get_worker(worker_uuid) {
+                Some(w) => w,
+                None => {
+                    tracing::error!("Worker not found: {}", worker_id);
+                    let error_event = WebUIEvent::Error {
+                        command: "prompt".to_string(),
+                        message: format!("Worker not found: {}", worker_id),
+                        timestamp: super::serialization::current_unix_timestamp(),
+                    };
+                    let _ = response_tx.send(error_event);
+                    return Ok(());
+                }
+            };
+
+            // Add message to conversation history
+            worker
+                .context_container
+                .conversation_history
+                .lock()
+                .unwrap()
+                .push_input_message(text.clone());
+
+            // Publish WebUI event for prompt received
+            session.event_bus().publish(crate::agent_env::AgentEnvironmentEvent::WebUI(
+                crate::agent_env::events::WebUIEvent::PromptReceived {
+                    worker_id: worker_uuid,
+                    text: text.clone(),
+                    timestamp: std::time::Instant::now(),
+                }
+            ));
+
+            // Launch agent loop
+            use crate::agent_env::worker_tasks::agent_loop::AgentLoopInput;
+            if let Err(e) = session.run_task__agent_loop(worker, AgentLoopInput {}) {
+                tracing::error!("Failed to start agent loop: {}", e);
+                let error_event = WebUIEvent::Error {
+                    command: "prompt".to_string(),
+                    message: format!("Failed to start agent loop: {}", e),
+                    timestamp: super::serialization::current_unix_timestamp(),
+                };
+                let _ = response_tx.send(error_event);
+                return Ok(());
+            }
+
+            tracing::info!("Started agent loop for worker {}", worker_uuid);
+        }
+        WebSocketCommand::Cancel { worker_id } => {
+            // Parse worker_id
+            let worker_uuid = match Uuid::parse_str(&worker_id) {
+                Ok(uuid) => uuid,
+                Err(_) => {
+                    tracing::error!("Invalid worker ID format: {}", worker_id);
+                    let error_event = WebUIEvent::Error {
+                        command: "cancel".to_string(),
+                        message: "Invalid worker ID format".to_string(),
+                        timestamp: super::serialization::current_unix_timestamp(),
+                    };
+                    let _ = response_tx.send(error_event);
+                    return Ok(());
+                }
+            };
+
+            // Cancel current job
+            if let Err(e) = session.cancel_worker_jobs(worker_uuid) {
+                tracing::error!("Failed to cancel job: {}", e);
+                let error_event = WebUIEvent::Error {
+                    command: "cancel".to_string(),
+                    message: format!("Failed to cancel job: {}", e),
+                    timestamp: super::serialization::current_unix_timestamp(),
+                };
+                let _ = response_tx.send(error_event);
+                return Ok(());
+            }
+            
+            tracing::info!("Cancelled job for worker {}", worker_uuid);
+        }
+        WebSocketCommand::CreateWorker { name, agent, working_directory } => {
+            tracing::info!("CreateWorker command received: name={:?}, agent={}, working_directory={:?}", 
+                name, agent, working_directory);
+            
+            // Generate worker name if not provided
+            let worker_name = name.unwrap_or_else(|| generate_worker_name(&agent, session));
+            
+            // Create worker using Session's build_worker (simplified for MVP)
+            // Note: For MVP, we're using the simple build_worker instead of WorkerBuilder
+            // to avoid complexity with agent loading. This can be enhanced later.
+            let worker = session.build_worker(worker_name.clone());
+            
+            // Store agent name and working directory in task_metadata for future use
+            {
+                let mut metadata = worker.task_metadata.lock().unwrap();
+                metadata.insert("agent".to_string(), serde_json::Value::String(agent.clone()));
+                if let Some(wd) = working_directory {
+                    metadata.insert("working_directory".to_string(), serde_json::Value::String(wd));
+                }
+            }
+            
+            tracing::info!("Created worker: {} with agent: {}", worker_name, agent);
+            // WorkerCreated event is automatically published by session.build_worker()
+        }
+        WebSocketCommand::GetWorkers => {
+            tracing::info!("GetWorkers command received");
+            
+            // Get all workers from session
+            let workers = session.get_workers();
+            
+            // Convert to WorkerMetadataJson
+            use super::serialization::{convert_worker_metadata, current_unix_timestamp};
+            let workers_metadata: Vec<_> = workers
+                .iter()
+                .map(|w| convert_worker_metadata(w))
+                .collect();
+            
+            // Create WorkersSnapshot event
+            let snapshot = WebUIEvent::WorkersSnapshot {
+                workers: workers_metadata,
+                timestamp: current_unix_timestamp(),
+            };
+            
+            // Send via response channel
+            if let Err(e) = response_tx.send(snapshot) {
+                tracing::error!("Failed to send WorkersSnapshot: {}", e);
+            }
+        }
+        WebSocketCommand::GetConversationHistory { worker_id } => {
+            tracing::info!("GetConversationHistory command received for worker {}", worker_id);
+            
+            // Parse worker_id
+            let worker_uuid = match Uuid::parse_str(&worker_id) {
+                Ok(uuid) => uuid,
+                Err(_) => {
+                    tracing::error!("Invalid worker ID format: {}", worker_id);
+                    let error_event = WebUIEvent::Error {
+                        command: "get_conversation_history".to_string(),
+                        message: "Invalid worker ID format".to_string(),
+                        timestamp: super::serialization::current_unix_timestamp(),
+                    };
+                    let _ = response_tx.send(error_event);
+                    return Ok(());
+                }
+            };
+            
+            // Get worker from session
+            let worker = match session.get_worker(worker_uuid) {
+                Some(w) => w,
+                None => {
+                    tracing::error!("Worker not found: {}", worker_id);
+                    let error_event = WebUIEvent::Error {
+                        command: "get_conversation_history".to_string(),
+                        message: format!("Worker not found: {}", worker_id),
+                        timestamp: super::serialization::current_unix_timestamp(),
+                    };
+                    let _ = response_tx.send(error_event);
+                    return Ok(());
+                }
+            };
+            
+            // Get conversation history from worker's context container
+            let history = worker
+                .context_container
+                .conversation_history
+                .lock()
+                .unwrap();
+            
+            // Convert entries to ConversationEntryJson
+            use super::serialization::{convert_conversation_entry, current_unix_timestamp};
+            let entries: Vec<_> = history
+                .get_entries()
+                .iter()
+                .map(convert_conversation_entry)
+                .collect();
+            
+            // Create ConversationSnapshot event
+            let snapshot = WebUIEvent::ConversationSnapshot {
+                worker_id,
+                entries,
+                timestamp: current_unix_timestamp(),
+            };
+            
+            // Send via response channel
+            if let Err(e) = response_tx.send(snapshot) {
+                tracing::error!("Failed to send ConversationSnapshot: {}", e);
+            }
+        }
+        WebSocketCommand::Ping => {
+            // No-op, just keep connection alive
+            tracing::debug!("Ping received");
+        }
+    }
+
+    Ok(())
+}
+
+/// Generate a unique worker name based on agent name and existing workers
+fn generate_worker_name(agent: &str, session: &Arc<Session>) -> String {
+    let workers = session.get_workers();
+    
+    // Count workers with same agent prefix
+    let count = workers.iter()
+        .filter(|w| w.name.starts_with(agent))
+        .count();
+    
+    format!("{}-{}", agent, count + 1)
+}
+
+/// Send initial snapshots on WebSocket connection
+async fn send_initial_snapshots(
+    sender: &mut futures::stream::SplitSink<WebSocket, Message>,
+    state: &AppState,
+) -> Result<()> {
+    use super::serialization::{convert_worker_metadata, convert_conversation_entry, current_unix_timestamp};
+    
+    // Send WorkersSnapshot
+    let workers = state.session.get_workers();
+    let workers_metadata: Vec<_> = workers
+        .iter()
+        .map(|w| convert_worker_metadata(w))
+        .collect();
+    
+    let workers_snapshot = WebUIEvent::WorkersSnapshot {
+        workers: workers_metadata,
+        timestamp: current_unix_timestamp(),
+    };
+    
+    let json = serde_json::to_string(&workers_snapshot)?;
+    sender.send(Message::Text(json)).await?;
+    
+    // Send ConversationSnapshot for main worker (if exists)
+    if let Some(main_worker) = workers.iter().find(|w| w.name == "main") {
+        let entries: Vec<_> = {
+            let history = main_worker
+                .context_container
+                .conversation_history
+                .lock()
+                .unwrap();
+            
+            history
+                .get_entries()
+                .iter()
+                .map(convert_conversation_entry)
+                .collect()
+        }; // history lock dropped here
+        
+        let conversation_snapshot = WebUIEvent::ConversationSnapshot {
+            worker_id: main_worker.id.to_string(),
+            entries,
+            timestamp: current_unix_timestamp(),
+        };
+        
+        let json = serde_json::to_string(&conversation_snapshot)?;
+        sender.send(Message::Text(json)).await?;
+    }
+    
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_parse_prompt_command() {
+        let json = r#"{"type": "prompt", "text": "Hello, world!"}"#;
+        let cmd: WebSocketCommand = serde_json::from_str(json).unwrap();
+        
+        match cmd {
+            WebSocketCommand::Prompt { text } => {
+                assert_eq!(text, "Hello, world!");
+            }
+            _ => panic!("Expected Prompt command"),
+        }
+    }
+
+    #[test]
+    fn test_parse_cancel_command() {
+        let json = r#"{"type": "cancel"}"#;
+        let cmd: WebSocketCommand = serde_json::from_str(json).unwrap();
+        
+        matches!(cmd, WebSocketCommand::Cancel);
+    }
+
+    #[test]
+    fn test_parse_ping_command() {
+        let json = r#"{"type": "ping"}"#;
+        let cmd: WebSocketCommand = serde_json::from_str(json).unwrap();
+        
+        matches!(cmd, WebSocketCommand::Ping);
+    }
+
+    #[test]
+    fn test_validate_prompt_empty() {
+        let cmd = WebSocketCommand::Prompt {
+            text: "   ".to_string(),
+        };
+        assert!(cmd.validate().is_err());
+    }
+
+    #[test]
+    fn test_validate_prompt_valid() {
+        let cmd = WebSocketCommand::Prompt {
+            text: "Hello".to_string(),
+        };
+        assert!(cmd.validate().is_ok());
+    }
+
+    #[test]
+    fn test_validate_cancel() {
+        let cmd = WebSocketCommand::Cancel;
+        assert!(cmd.validate().is_ok());
+    }
+
+    #[test]
+    fn test_validate_ping() {
+        let cmd = WebSocketCommand::Ping;
+        assert!(cmd.validate().is_ok());
+    }
+}
diff --git a/crates/chat-cli/src/cli/mod.rs b/crates/chat-cli/src/cli/mod.rs
index 523900d63..c00634d3e 100644
--- a/crates/chat-cli/src/cli/mod.rs
+++ b/crates/chat-cli/src/cli/mod.rs
@@ -383,6 +383,8 @@ mod test {
                 trust_tools: None,
                 no_interactive: false,
                 wrap: None,
+                ui_mode: None,
+                platform: None,
             })),
             verbose: 2,
             help_all: false,
@@ -423,6 +425,8 @@ mod test {
                 trust_tools: None,
                 no_interactive: false,
                 wrap: None,
+                ui_mode: None,
+                platform: None,
             })
         );
     }
@@ -439,6 +443,8 @@ mod test {
                 trust_all_tools: false,
                 trust_tools: None,
                 no_interactive: false,
+                ui_mode: None,
+                platform: None,
                 wrap: None,
             })
         );
@@ -456,6 +462,8 @@ mod test {
                 trust_all_tools: true,
                 trust_tools: None,
                 no_interactive: false,
+                ui_mode: None,
+                platform: None,
                 wrap: None,
             })
         );
@@ -473,6 +481,8 @@ mod test {
                 trust_all_tools: false,
                 trust_tools: None,
                 no_interactive: true,
+                ui_mode: None,
+                platform: None,
                 wrap: None,
             })
         );
@@ -486,6 +496,8 @@ mod test {
                 trust_all_tools: false,
                 trust_tools: None,
                 no_interactive: true,
+                ui_mode: None,
+                platform: None,
                 wrap: None,
             })
         );
@@ -503,6 +515,8 @@ mod test {
                 trust_all_tools: true,
                 trust_tools: None,
                 no_interactive: false,
+                ui_mode: None,
+                platform: None,
                 wrap: None,
             })
         );
@@ -520,6 +534,8 @@ mod test {
                 trust_all_tools: false,
                 trust_tools: Some(vec!["".to_string()]),
                 no_interactive: false,
+                ui_mode: None,
+                platform: None,
                 wrap: None,
             })
         );
@@ -537,6 +553,8 @@ mod test {
                 trust_all_tools: false,
                 trust_tools: Some(vec!["fs_read".to_string(), "fs_write".to_string()]),
                 no_interactive: false,
+                ui_mode: None,
+                platform: None,
                 wrap: None,
             })
         );
@@ -554,6 +572,8 @@ mod test {
                 trust_all_tools: false,
                 trust_tools: None,
                 no_interactive: false,
+                ui_mode: None,
+                platform: None,
                 wrap: Some(Never),
             })
         );
@@ -567,6 +587,8 @@ mod test {
                 trust_all_tools: false,
                 trust_tools: None,
                 no_interactive: false,
+                ui_mode: None,
+                platform: None,
                 wrap: Some(Always),
             })
         );
@@ -580,6 +602,8 @@ mod test {
                 trust_all_tools: false,
                 trust_tools: None,
                 no_interactive: false,
+                ui_mode: None,
+                platform: None,
                 wrap: Some(Auto),
             })
         );
diff --git a/crates/chat-cli/src/lib.rs b/crates/chat-cli/src/lib.rs
index 2e9bc4baf..0ed3c571f 100644
--- a/crates/chat-cli/src/lib.rs
+++ b/crates/chat-cli/src/lib.rs
@@ -2,6 +2,7 @@
 //! This lib.rs is only here for testing purposes.
 //! `test_mcp_server/test_server.rs` is declared as a separate binary and would need a way to
 //! reference types defined inside of this crate, hence the export.
+pub mod agent_env;
 pub mod api_client;
 pub mod auth;
 pub mod aws_common;
diff --git a/crates/chat-cli/src/main.rs b/crates/chat-cli/src/main.rs
index c4f031755..5c3983fae 100644
--- a/crates/chat-cli/src/main.rs
+++ b/crates/chat-cli/src/main.rs
@@ -1,3 +1,4 @@
+mod agent_env;
 mod api_client;
 mod auth;
 mod aws_common;
diff --git a/crates/chat-exp/Cargo.lock b/crates/chat-exp/Cargo.lock
new file mode 100644
index 000000000..3a499eda5
--- /dev/null
+++ b/crates/chat-exp/Cargo.lock
@@ -0,0 +1,2466 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "addr2line"
+version = "0.25.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b5d307320b3181d6d7954e663bd7c774a838b8220fe0593c86d9fb09f498b4b"
+dependencies = [
+ "gimli",
+]
+
+[[package]]
+name = "adler2"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
+
+[[package]]
+name = "aho-corasick"
+version = "1.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "anyhow"
+version = "1.0.100"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a23eb6b1614318a8071c9b2521f36b424b2c83db5eb3a0fead4a6c0809af6e61"
+
+[[package]]
+name = "async-trait"
+version = "0.1.89"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9035ad2d096bed7955a320ee7e2230574d28fd3c3a0f186cbea1ff3c7eed5dbb"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "atomic-waker"
+version = "1.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0"
+
+[[package]]
+name = "autocfg"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
+
+[[package]]
+name = "aws-config"
+version = "1.8.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "04b37ddf8d2e9744a0b9c19ce0b78efe4795339a90b66b7bae77987092cd2e69"
+dependencies = [
+ "aws-credential-types",
+ "aws-runtime",
+ "aws-sdk-sso",
+ "aws-sdk-ssooidc",
+ "aws-sdk-sts",
+ "aws-smithy-async",
+ "aws-smithy-http",
+ "aws-smithy-json",
+ "aws-smithy-runtime",
+ "aws-smithy-runtime-api",
+ "aws-smithy-types",
+ "aws-types",
+ "bytes",
+ "fastrand",
+ "hex",
+ "http 1.3.1",
+ "ring",
+ "time",
+ "tokio",
+ "tracing",
+ "url",
+ "zeroize",
+]
+
+[[package]]
+name = "aws-credential-types"
+version = "1.2.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "799a1290207254984cb7c05245111bc77958b92a3c9bb449598044b36341cce6"
+dependencies = [
+ "aws-smithy-async",
+ "aws-smithy-runtime-api",
+ "aws-smithy-types",
+ "zeroize",
+]
+
+[[package]]
+name = "aws-lc-rs"
+version = "1.14.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "879b6c89592deb404ba4dc0ae6b58ffd1795c78991cbb5b8bc441c48a070440d"
+dependencies = [
+ "aws-lc-sys",
+ "zeroize",
+]
+
+[[package]]
+name = "aws-lc-sys"
+version = "0.32.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a2b715a6010afb9e457ca2b7c9d2b9c344baa8baed7b38dc476034c171b32575"
+dependencies = [
+ "bindgen",
+ "cc",
+ "cmake",
+ "dunce",
+ "fs_extra",
+ "libloading",
+]
+
+[[package]]
+name = "aws-runtime"
+version = "1.5.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2e1ed337dabcf765ad5f2fb426f13af22d576328aaf09eac8f70953530798ec0"
+dependencies = [
+ "aws-credential-types",
+ "aws-sigv4",
+ "aws-smithy-async",
+ "aws-smithy-eventstream",
+ "aws-smithy-http",
+ "aws-smithy-runtime",
+ "aws-smithy-runtime-api",
+ "aws-smithy-types",
+ "aws-types",
+ "bytes",
+ "fastrand",
+ "http 0.2.12",
+ "http-body 0.4.6",
+ "percent-encoding",
+ "pin-project-lite",
+ "tracing",
+ "uuid",
+]
+
+[[package]]
+name = "aws-sdk-bedrockruntime"
+version = "1.108.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed130f6272d73c74add30ee17835c475c89271786b0c70e81342556ed15e3d4e"
+dependencies = [
+ "aws-credential-types",
+ "aws-runtime",
+ "aws-sigv4",
+ "aws-smithy-async",
+ "aws-smithy-eventstream",
+ "aws-smithy-http",
+ "aws-smithy-json",
+ "aws-smithy-runtime",
+ "aws-smithy-runtime-api",
+ "aws-smithy-types",
+ "aws-types",
+ "bytes",
+ "fastrand",
+ "http 0.2.12",
+ "hyper 0.14.32",
+ "regex-lite",
+ "tracing",
+]
+
+[[package]]
+name = "aws-sdk-sso"
+version = "1.85.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2f2c741e2e439f07b5d1b33155e246742353d82167c785a2ff547275b7e32483"
+dependencies = [
+ "aws-credential-types",
+ "aws-runtime",
+ "aws-smithy-async",
+ "aws-smithy-http",
+ "aws-smithy-json",
+ "aws-smithy-runtime",
+ "aws-smithy-runtime-api",
+ "aws-smithy-types",
+ "aws-types",
+ "bytes",
+ "fastrand",
+ "http 0.2.12",
+ "regex-lite",
+ "tracing",
+]
+
+[[package]]
+name = "aws-sdk-ssooidc"
+version = "1.87.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6428ae5686b18c0ee99f6f3c39d94ae3f8b42894cdc35c35d8fb2470e9db2d4c"
+dependencies = [
+ "aws-credential-types",
+ "aws-runtime",
+ "aws-smithy-async",
+ "aws-smithy-http",
+ "aws-smithy-json",
+ "aws-smithy-runtime",
+ "aws-smithy-runtime-api",
+ "aws-smithy-types",
+ "aws-types",
+ "bytes",
+ "fastrand",
+ "http 0.2.12",
+ "regex-lite",
+ "tracing",
+]
+
+[[package]]
+name = "aws-sdk-sts"
+version = "1.87.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5871bec9a79a3e8d928c7788d654f135dde0e71d2dd98089388bab36b37ef607"
+dependencies = [
+ "aws-credential-types",
+ "aws-runtime",
+ "aws-smithy-async",
+ "aws-smithy-http",
+ "aws-smithy-json",
+ "aws-smithy-query",
+ "aws-smithy-runtime",
+ "aws-smithy-runtime-api",
+ "aws-smithy-types",
+ "aws-smithy-xml",
+ "aws-types",
+ "fastrand",
+ "http 0.2.12",
+ "regex-lite",
+ "tracing",
+]
+
+[[package]]
+name = "aws-sigv4"
+version = "1.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "084c34162187d39e3740cb635acd73c4e3a551a36146ad6fe8883c929c9f876c"
+dependencies = [
+ "aws-credential-types",
+ "aws-smithy-eventstream",
+ "aws-smithy-http",
+ "aws-smithy-runtime-api",
+ "aws-smithy-types",
+ "bytes",
+ "form_urlencoded",
+ "hex",
+ "hmac",
+ "http 0.2.12",
+ "http 1.3.1",
+ "percent-encoding",
+ "sha2",
+ "time",
+ "tracing",
+]
+
+[[package]]
+name = "aws-smithy-async"
+version = "1.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e190749ea56f8c42bf15dd76c65e14f8f765233e6df9b0506d9d934ebef867c"
+dependencies = [
+ "futures-util",
+ "pin-project-lite",
+ "tokio",
+]
+
+[[package]]
+name = "aws-smithy-eventstream"
+version = "0.60.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "182b03393e8c677347fb5705a04a9392695d47d20ef0a2f8cfe28c8e6b9b9778"
+dependencies = [
+ "aws-smithy-types",
+ "bytes",
+ "crc32fast",
+]
+
+[[package]]
+name = "aws-smithy-http"
+version = "0.62.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7c4dacf2d38996cf729f55e7a762b30918229917eca115de45dfa8dfb97796c9"
+dependencies = [
+ "aws-smithy-eventstream",
+ "aws-smithy-runtime-api",
+ "aws-smithy-types",
+ "bytes",
+ "bytes-utils",
+ "futures-core",
+ "http 0.2.12",
+ "http 1.3.1",
+ "http-body 0.4.6",
+ "percent-encoding",
+ "pin-project-lite",
+ "pin-utils",
+ "tracing",
+]
+
+[[package]]
+name = "aws-smithy-http-client"
+version = "1.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "734b4282fbb7372923ac339cc2222530f8180d9d4745e582de19a18cee409fd8"
+dependencies = [
+ "aws-smithy-async",
+ "aws-smithy-runtime-api",
+ "aws-smithy-types",
+ "h2 0.3.27",
+ "h2 0.4.12",
+ "http 0.2.12",
+ "http 1.3.1",
+ "http-body 0.4.6",
+ "hyper 0.14.32",
+ "hyper 1.7.0",
+ "hyper-rustls 0.24.2",
+ "hyper-rustls 0.27.7",
+ "hyper-util",
+ "pin-project-lite",
+ "rustls 0.21.12",
+ "rustls 0.23.32",
+ "rustls-native-certs 0.8.1",
+ "rustls-pki-types",
+ "tokio",
+ "tokio-rustls 0.26.4",
+ "tower",
+ "tracing",
+]
+
+[[package]]
+name = "aws-smithy-json"
+version = "0.61.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eaa31b350998e703e9826b2104dd6f63be0508666e1aba88137af060e8944047"
+dependencies = [
+ "aws-smithy-types",
+]
+
+[[package]]
+name = "aws-smithy-observability"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9364d5989ac4dd918e5cc4c4bdcc61c9be17dcd2586ea7f69e348fc7c6cab393"
+dependencies = [
+ "aws-smithy-runtime-api",
+]
+
+[[package]]
+name = "aws-smithy-query"
+version = "0.60.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2fbd61ceb3fe8a1cb7352e42689cec5335833cd9f94103a61e98f9bb61c64bb"
+dependencies = [
+ "aws-smithy-types",
+ "urlencoding",
+]
+
+[[package]]
+name = "aws-smithy-runtime"
+version = "1.9.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4fa63ad37685ceb7762fa4d73d06f1d5493feb88e3f27259b9ed277f4c01b185"
+dependencies = [
+ "aws-smithy-async",
+ "aws-smithy-http",
+ "aws-smithy-http-client",
+ "aws-smithy-observability",
+ "aws-smithy-runtime-api",
+ "aws-smithy-types",
+ "bytes",
+ "fastrand",
+ "http 0.2.12",
+ "http 1.3.1",
+ "http-body 0.4.6",
+ "http-body 1.0.1",
+ "pin-project-lite",
+ "pin-utils",
+ "tokio",
+ "tracing",
+]
+
+[[package]]
+name = "aws-smithy-runtime-api"
+version = "1.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "07f5e0fc8a6b3f2303f331b94504bbf754d85488f402d6f1dd7a6080f99afe56"
+dependencies = [
+ "aws-smithy-async",
+ "aws-smithy-types",
+ "bytes",
+ "http 0.2.12",
+ "http 1.3.1",
+ "pin-project-lite",
+ "tokio",
+ "tracing",
+ "zeroize",
+]
+
+[[package]]
+name = "aws-smithy-types"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d498595448e43de7f4296b7b7a18a8a02c61ec9349128c80a368f7c3b4ab11a8"
+dependencies = [
+ "base64-simd",
+ "bytes",
+ "bytes-utils",
+ "futures-core",
+ "http 0.2.12",
+ "http 1.3.1",
+ "http-body 0.4.6",
+ "http-body 1.0.1",
+ "http-body-util",
+ "itoa",
+ "num-integer",
+ "pin-project-lite",
+ "pin-utils",
+ "ryu",
+ "serde",
+ "time",
+ "tokio",
+ "tokio-util",
+]
+
+[[package]]
+name = "aws-smithy-xml"
+version = "0.60.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3db87b96cb1b16c024980f133968d52882ca0daaee3a086c6decc500f6c99728"
+dependencies = [
+ "xmlparser",
+]
+
+[[package]]
+name = "aws-types"
+version = "1.3.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b069d19bf01e46298eaedd7c6f283fe565a59263e53eebec945f3e6398f42390"
+dependencies = [
+ "aws-credential-types",
+ "aws-smithy-async",
+ "aws-smithy-runtime-api",
+ "aws-smithy-types",
+ "rustc_version",
+ "tracing",
+]
+
+[[package]]
+name = "backtrace"
+version = "0.3.76"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb531853791a215d7c62a30daf0dde835f381ab5de4589cfe7c649d2cbe92bd6"
+dependencies = [
+ "addr2line",
+ "cfg-if",
+ "libc",
+ "miniz_oxide",
+ "object",
+ "rustc-demangle",
+ "windows-link",
+]
+
+[[package]]
+name = "base64"
+version = "0.21.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d297deb1925b89f2ccc13d7635fa0714f12c87adce1c75356b39ca9b7178567"
+
+[[package]]
+name = "base64"
+version = "0.22.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
+
+[[package]]
+name = "base64-simd"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "339abbe78e73178762e23bea9dfd08e697eb3f3301cd4be981c0f78ba5859195"
+dependencies = [
+ "outref",
+ "vsimd",
+]
+
+[[package]]
+name = "bindgen"
+version = "0.72.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "993776b509cfb49c750f11b8f07a46fa23e0a1386ffc01fb1e7d343efc387895"
+dependencies = [
+ "bitflags",
+ "cexpr",
+ "clang-sys",
+ "itertools",
+ "log",
+ "prettyplease",
+ "proc-macro2",
+ "quote",
+ "regex",
+ "rustc-hash",
+ "shlex",
+ "syn",
+]
+
+[[package]]
+name = "bitflags"
+version = "2.9.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2261d10cca569e4643e526d8dc2e62e433cc8aba21ab764233731f8d369bf394"
+
+[[package]]
+name = "block-buffer"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "bumpalo"
+version = "3.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "46c5e41b57b8bba42a04676d81cb89e9ee8e859a1a66f80a5a72e1cb76b34d43"
+
+[[package]]
+name = "bytes"
+version = "1.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d71b6127be86fdcfddb610f7182ac57211d4b18a3e9c82eb2d17662f2227ad6a"
+
+[[package]]
+name = "bytes-utils"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7dafe3a8757b027e2be6e4e5601ed563c55989fcf1546e933c66c8eb3a058d35"
+dependencies = [
+ "bytes",
+ "either",
+]
+
+[[package]]
+name = "cc"
+version = "1.2.40"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e1d05d92f4b1fd76aad469d46cdd858ca761576082cd37df81416691e50199fb"
+dependencies = [
+ "find-msvc-tools",
+ "jobserver",
+ "libc",
+ "shlex",
+]
+
+[[package]]
+name = "cexpr"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6fac387a98bb7c37292057cffc56d62ecb629900026402633ae9160df93a8766"
+dependencies = [
+ "nom",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2fd1289c04a9ea8cb22300a459a72a385d7c73d3259e2ed7dcb2af674838cfa9"
+
+[[package]]
+name = "chat-exp2"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "async-trait",
+ "aws-config",
+ "aws-credential-types",
+ "aws-sdk-bedrockruntime",
+ "futures",
+ "serde_json",
+ "tokio",
+ "tokio-util",
+ "uuid",
+]
+
+[[package]]
+name = "clang-sys"
+version = "1.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b023947811758c97c59bf9d1c188fd619ad4718dcaa767947df1cadb14f39f4"
+dependencies = [
+ "glob",
+ "libc",
+ "libloading",
+]
+
+[[package]]
+name = "cmake"
+version = "0.1.54"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7caa3f9de89ddbe2c607f4101924c5abec803763ae9534e4f4d7d8f84aa81f0"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "core-foundation"
+version = "0.9.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91e195e091a93c46f7102ec7818a2aa394e1e1771c3ab4825963fa03e45afb8f"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
+[[package]]
+name = "core-foundation"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b2a6cd9ae233e7f62ba4e9353e81a88df7fc8a5987b8d445b4d90c879bd156f6"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
+[[package]]
+name = "core-foundation-sys"
+version = "0.8.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
+
+[[package]]
+name = "cpufeatures"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "crc32fast"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9481c1c90cbf2ac953f07c8d4a58aa3945c425b7185c9154d67a65e4230da511"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "crypto-common"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
+dependencies = [
+ "generic-array",
+ "typenum",
+]
+
+[[package]]
+name = "deranged"
+version = "0.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a41953f86f8a05768a6cda24def994fd2f424b04ec5c719cf89989779f199071"
+dependencies = [
+ "powerfmt",
+]
+
+[[package]]
+name = "digest"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
+dependencies = [
+ "block-buffer",
+ "crypto-common",
+ "subtle",
+]
+
+[[package]]
+name = "displaydoc"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "dunce"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92773504d58c093f6de2459af4af33faa518c13451eb8f2b5698ed3d36e7c813"
+
+[[package]]
+name = "either"
+version = "1.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
+
+[[package]]
+name = "equivalent"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
+
+[[package]]
+name = "fastrand"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
+
+[[package]]
+name = "find-msvc-tools"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0399f9d26e5191ce32c498bebd31e7a3ceabc2745f0ac54af3f335126c3f24b3"
+
+[[package]]
+name = "fnv"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
+
+[[package]]
+name = "form_urlencoded"
+version = "1.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb4cb245038516f5f85277875cdaa4f7d2c9a0fa0468de06ed190163b1581fcf"
+dependencies = [
+ "percent-encoding",
+]
+
+[[package]]
+name = "fs_extra"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42703706b716c37f96a77aea830392ad231f44c9e9a67872fa5548707e11b11c"
+
+[[package]]
+name = "futures"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "65bc07b1a8bc7c85c5f2e110c476c7389b4554ba72af57d8445ea63a576b0876"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "futures-executor",
+ "futures-io",
+ "futures-sink",
+ "futures-task",
+ "futures-util",
+]
+
+[[package]]
+name = "futures-channel"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2dff15bf788c671c1934e366d07e30c1814a8ef514e1af724a602e8a2fbe1b10"
+dependencies = [
+ "futures-core",
+ "futures-sink",
+]
+
+[[package]]
+name = "futures-core"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05f29059c0c2090612e8d742178b0580d2dc940c837851ad723096f87af6663e"
+
+[[package]]
+name = "futures-executor"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e28d1d997f585e54aebc3f97d39e72338912123a67330d723fdbb564d646c9f"
+dependencies = [
+ "futures-core",
+ "futures-task",
+ "futures-util",
+]
+
+[[package]]
+name = "futures-io"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e5c1b78ca4aae1ac06c48a526a655760685149f0d465d21f37abfe57ce075c6"
+
+[[package]]
+name = "futures-macro"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "162ee34ebcb7c64a8abebc059ce0fee27c2262618d7b60ed8faf72fef13c3650"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "futures-sink"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e575fab7d1e0dcb8d0c7bcf9a63ee213816ab51902e6d244a95819acacf1d4f7"
+
+[[package]]
+name = "futures-task"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f90f7dce0722e95104fcb095585910c0977252f286e354b5e3bd38902cd99988"
+
+[[package]]
+name = "futures-util"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9fa08315bb612088cc391249efdc3bc77536f16c91f6cf495e6fbe85b20a4a81"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "futures-io",
+ "futures-macro",
+ "futures-sink",
+ "futures-task",
+ "memchr",
+ "pin-project-lite",
+ "pin-utils",
+ "slab",
+]
+
+[[package]]
+name = "generic-array"
+version = "0.14.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
+dependencies = [
+ "typenum",
+ "version_check",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "335ff9f135e4384c8150d6f27c6daed433577f86b4750418338c01a1a2528592"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi 0.11.1+wasi-snapshot-preview1",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "26145e563e54f2cadc477553f1ec5ee650b00862f0a58bcd12cbdc5f0ea2d2f4"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "r-efi",
+ "wasi 0.14.7+wasi-0.2.4",
+]
+
+[[package]]
+name = "gimli"
+version = "0.32.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e629b9b98ef3dd8afe6ca2bd0f89306cec16d43d907889945bc5d6687f2f13c7"
+
+[[package]]
+name = "glob"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0cc23270f6e1808e30a928bdc84dea0b9b4136a8bc82338574f23baf47bbd280"
+
+[[package]]
+name = "h2"
+version = "0.3.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0beca50380b1fc32983fc1cb4587bfa4bb9e78fc259aad4a0032d2080309222d"
+dependencies = [
+ "bytes",
+ "fnv",
+ "futures-core",
+ "futures-sink",
+ "futures-util",
+ "http 0.2.12",
+ "indexmap",
+ "slab",
+ "tokio",
+ "tokio-util",
+ "tracing",
+]
+
+[[package]]
+name = "h2"
+version = "0.4.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f3c0b69cfcb4e1b9f1bf2f53f95f766e4661169728ec61cd3fe5a0166f2d1386"
+dependencies = [
+ "atomic-waker",
+ "bytes",
+ "fnv",
+ "futures-core",
+ "futures-sink",
+ "http 1.3.1",
+ "indexmap",
+ "slab",
+ "tokio",
+ "tokio-util",
+ "tracing",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.16.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5419bdc4f6a9207fbeba6d11b604d481addf78ecd10c11ad51e76c2f6482748d"
+
+[[package]]
+name = "hex"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
+
+[[package]]
+name = "hmac"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e"
+dependencies = [
+ "digest",
+]
+
+[[package]]
+name = "http"
+version = "0.2.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "601cbb57e577e2f5ef5be8e7b83f0f63994f25aa94d673e54a92d5c516d101f1"
+dependencies = [
+ "bytes",
+ "fnv",
+ "itoa",
+]
+
+[[package]]
+name = "http"
+version = "1.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f4a85d31aea989eead29a3aaf9e1115a180df8282431156e533de47660892565"
+dependencies = [
+ "bytes",
+ "fnv",
+ "itoa",
+]
+
+[[package]]
+name = "http-body"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7ceab25649e9960c0311ea418d17bee82c0dcec1bd053b5f9a66e265a693bed2"
+dependencies = [
+ "bytes",
+ "http 0.2.12",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "http-body"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1efedce1fb8e6913f23e0c92de8e62cd5b772a67e7b3946df930a62566c93184"
+dependencies = [
+ "bytes",
+ "http 1.3.1",
+]
+
+[[package]]
+name = "http-body-util"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b021d93e26becf5dc7e1b75b1bed1fd93124b374ceb73f43d4d4eafec896a64a"
+dependencies = [
+ "bytes",
+ "futures-core",
+ "http 1.3.1",
+ "http-body 1.0.1",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "httparse"
+version = "1.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87"
+
+[[package]]
+name = "httpdate"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9"
+
+[[package]]
+name = "hyper"
+version = "0.14.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41dfc780fdec9373c01bae43289ea34c972e40ee3c9f6b3c8801a35f35586ce7"
+dependencies = [
+ "bytes",
+ "futures-channel",
+ "futures-core",
+ "futures-util",
+ "h2 0.3.27",
+ "http 0.2.12",
+ "http-body 0.4.6",
+ "httparse",
+ "httpdate",
+ "itoa",
+ "pin-project-lite",
+ "socket2 0.5.10",
+ "tokio",
+ "tower-service",
+ "tracing",
+ "want",
+]
+
+[[package]]
+name = "hyper"
+version = "1.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eb3aa54a13a0dfe7fbe3a59e0c76093041720fdc77b110cc0fc260fafb4dc51e"
+dependencies = [
+ "atomic-waker",
+ "bytes",
+ "futures-channel",
+ "futures-core",
+ "h2 0.4.12",
+ "http 1.3.1",
+ "http-body 1.0.1",
+ "httparse",
+ "itoa",
+ "pin-project-lite",
+ "pin-utils",
+ "smallvec",
+ "tokio",
+ "want",
+]
+
+[[package]]
+name = "hyper-rustls"
+version = "0.24.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec3efd23720e2049821a693cbc7e65ea87c72f1c58ff2f9522ff332b1491e590"
+dependencies = [
+ "futures-util",
+ "http 0.2.12",
+ "hyper 0.14.32",
+ "log",
+ "rustls 0.21.12",
+ "rustls-native-certs 0.6.3",
+ "tokio",
+ "tokio-rustls 0.24.1",
+]
+
+[[package]]
+name = "hyper-rustls"
+version = "0.27.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3c93eb611681b207e1fe55d5a71ecf91572ec8a6705cdb6857f7d8d5242cf58"
+dependencies = [
+ "http 1.3.1",
+ "hyper 1.7.0",
+ "hyper-util",
+ "rustls 0.23.32",
+ "rustls-native-certs 0.8.1",
+ "rustls-pki-types",
+ "tokio",
+ "tokio-rustls 0.26.4",
+ "tower-service",
+]
+
+[[package]]
+name = "hyper-util"
+version = "0.1.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3c6995591a8f1380fcb4ba966a252a4b29188d51d2b89e3a252f5305be65aea8"
+dependencies = [
+ "base64 0.22.1",
+ "bytes",
+ "futures-channel",
+ "futures-core",
+ "futures-util",
+ "http 1.3.1",
+ "http-body 1.0.1",
+ "hyper 1.7.0",
+ "ipnet",
+ "libc",
+ "percent-encoding",
+ "pin-project-lite",
+ "socket2 0.6.0",
+ "tokio",
+ "tower-service",
+ "tracing",
+]
+
+[[package]]
+name = "icu_collections"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "200072f5d0e3614556f94a9930d5dc3e0662a652823904c3a75dc3b0af7fee47"
+dependencies = [
+ "displaydoc",
+ "potential_utf",
+ "yoke",
+ "zerofrom",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_locale_core"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0cde2700ccaed3872079a65fb1a78f6c0a36c91570f28755dda67bc8f7d9f00a"
+dependencies = [
+ "displaydoc",
+ "litemap",
+ "tinystr",
+ "writeable",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_normalizer"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "436880e8e18df4d7bbc06d58432329d6458cc84531f7ac5f024e93deadb37979"
+dependencies = [
+ "displaydoc",
+ "icu_collections",
+ "icu_normalizer_data",
+ "icu_properties",
+ "icu_provider",
+ "smallvec",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_normalizer_data"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "00210d6893afc98edb752b664b8890f0ef174c8adbb8d0be9710fa66fbbf72d3"
+
+[[package]]
+name = "icu_properties"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "016c619c1eeb94efb86809b015c58f479963de65bdb6253345c1a1276f22e32b"
+dependencies = [
+ "displaydoc",
+ "icu_collections",
+ "icu_locale_core",
+ "icu_properties_data",
+ "icu_provider",
+ "potential_utf",
+ "zerotrie",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_properties_data"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "298459143998310acd25ffe6810ed544932242d3f07083eee1084d83a71bd632"
+
+[[package]]
+name = "icu_provider"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "03c80da27b5f4187909049ee2d72f276f0d9f99a42c306bd0131ecfe04d8e5af"
+dependencies = [
+ "displaydoc",
+ "icu_locale_core",
+ "stable_deref_trait",
+ "tinystr",
+ "writeable",
+ "yoke",
+ "zerofrom",
+ "zerotrie",
+ "zerovec",
+]
+
+[[package]]
+name = "idna"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b0875f23caa03898994f6ddc501886a45c7d3d62d04d2d90788d47be1b1e4de"
+dependencies = [
+ "idna_adapter",
+ "smallvec",
+ "utf8_iter",
+]
+
+[[package]]
+name = "idna_adapter"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3acae9609540aa318d1bc588455225fb2085b9ed0c4f6bd0d9d5bcd86f1a0344"
+dependencies = [
+ "icu_normalizer",
+ "icu_properties",
+]
+
+[[package]]
+name = "indexmap"
+version = "2.11.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4b0f83760fb341a774ed326568e19f5a863af4a952def8c39f9ab92fd95b88e5"
+dependencies = [
+ "equivalent",
+ "hashbrown",
+]
+
+[[package]]
+name = "io-uring"
+version = "0.7.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "046fa2d4d00aea763528b4950358d0ead425372445dc8ff86312b3c69ff7727b"
+dependencies = [
+ "bitflags",
+ "cfg-if",
+ "libc",
+]
+
+[[package]]
+name = "ipnet"
+version = "2.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "469fb0b9cefa57e3ef31275ee7cacb78f2fdca44e4765491884a2b119d4eb130"
+
+[[package]]
+name = "itertools"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "itoa"
+version = "1.0.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"
+
+[[package]]
+name = "jobserver"
+version = "0.1.34"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9afb3de4395d6b3e67a780b6de64b51c978ecf11cb9a462c66be7d4ca9039d33"
+dependencies = [
+ "getrandom 0.3.3",
+ "libc",
+]
+
+[[package]]
+name = "js-sys"
+version = "0.3.81"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec48937a97411dcb524a265206ccd4c90bb711fca92b2792c407f268825b9305"
+dependencies = [
+ "once_cell",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.176"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "58f929b4d672ea937a23a1ab494143d968337a5f47e56d0815df1e0890ddf174"
+
+[[package]]
+name = "libloading"
+version = "0.8.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "07033963ba89ebaf1584d767badaa2e8fcec21aedea6b8c0346d487d49c28667"
+dependencies = [
+ "cfg-if",
+ "windows-targets 0.53.4",
+]
+
+[[package]]
+name = "litemap"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "241eaef5fd12c88705a01fc1066c48c4b36e0dd4377dcdc7ec3942cea7a69956"
+
+[[package]]
+name = "lock_api"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "224399e74b87b5f3557511d98dff8b14089b3dadafcab6bb93eab67d3aace965"
+dependencies = [
+ "scopeguard",
+]
+
+[[package]]
+name = "log"
+version = "0.4.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34080505efa8e45a4b816c349525ebe327ceaa8559756f0356cba97ef3bf7432"
+
+[[package]]
+name = "memchr"
+version = "2.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f52b00d39961fc5b2736ea853c9cc86238e165017a493d1d5c8eac6bdc4cc273"
+
+[[package]]
+name = "minimal-lexical"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
+
+[[package]]
+name = "miniz_oxide"
+version = "0.8.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316"
+dependencies = [
+ "adler2",
+]
+
+[[package]]
+name = "mio"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78bed444cc8a2160f01cbcf811ef18cac863ad68ae8ca62092e8db51d51c761c"
+dependencies = [
+ "libc",
+ "wasi 0.11.1+wasi-snapshot-preview1",
+ "windows-sys 0.59.0",
+]
+
+[[package]]
+name = "nom"
+version = "7.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a"
+dependencies = [
+ "memchr",
+ "minimal-lexical",
+]
+
+[[package]]
+name = "num-conv"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51d515d32fb182ee37cda2ccdcb92950d6a3c2893aa280e540671c2cd0f3b1d9"
+
+[[package]]
+name = "num-integer"
+version = "0.1.46"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "num-traits"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "object"
+version = "0.37.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff76201f031d8863c38aa7f905eca4f53abbfa15f609db4277d44cd8938f33fe"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.21.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
+
+[[package]]
+name = "openssl-probe"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d05e27ee213611ffe7d6348b942e8f942b37114c00cc03cec254295a4a17852e"
+
+[[package]]
+name = "outref"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a80800c0488c3a21695ea981a54918fbb37abf04f4d0720c453632255e2ff0e"
+
+[[package]]
+name = "parking_lot"
+version = "0.12.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93857453250e3077bd71ff98b6a65ea6621a19bb0f559a85248955ac12c45a1a"
+dependencies = [
+ "lock_api",
+ "parking_lot_core",
+]
+
+[[package]]
+name = "parking_lot_core"
+version = "0.9.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "redox_syscall",
+ "smallvec",
+ "windows-link",
+]
+
+[[package]]
+name = "percent-encoding"
+version = "2.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
+
+[[package]]
+name = "pin-project-lite"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b3cff922bd51709b605d9ead9aa71031d81447142d828eb4a6eba76fe619f9b"
+
+[[package]]
+name = "pin-utils"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
+
+[[package]]
+name = "potential_utf"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "84df19adbe5b5a0782edcab45899906947ab039ccf4573713735ee7de1e6b08a"
+dependencies = [
+ "zerovec",
+]
+
+[[package]]
+name = "powerfmt"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391"
+
+[[package]]
+name = "prettyplease"
+version = "0.2.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b"
+dependencies = [
+ "proc-macro2",
+ "syn",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.101"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "89ae43fd86e4158d6db51ad8e2b80f313af9cc74f5c0e03ccb87de09998732de"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.41"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ce25767e7b499d1b604768e7cde645d14cc8584231ea6b295e9c9eb22c02e1d1"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "r-efi"
+version = "5.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
+
+[[package]]
+name = "redox_syscall"
+version = "0.5.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d"
+dependencies = [
+ "bitflags",
+]
+
+[[package]]
+name = "regex"
+version = "1.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b5288124840bee7b386bc413c487869b360b2b4ec421ea56425128692f2a82c"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-automata",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "833eb9ce86d40ef33cb1306d8accf7bc8ec2bfea4355cbdebb3df68b40925cad"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-lite"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "943f41321c63ef1c92fd763bfe054d2668f7f225a5c29f0105903dc2fc04ba30"
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "caf4aa5b0f434c91fe5c7f1ecb6a5ece2130b02ad2a590589dda5146df959001"
+
+[[package]]
+name = "ring"
+version = "0.17.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4689e6c2294d81e88dc6261c768b63bc4fcdb852be6d1352498b114f61383b7"
+dependencies = [
+ "cc",
+ "cfg-if",
+ "getrandom 0.2.16",
+ "libc",
+ "untrusted",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "rustc-demangle"
+version = "0.1.26"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56f7d92ca342cea22a06f2121d944b4fd82af56988c270852495420f961d4ace"
+
+[[package]]
+name = "rustc-hash"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d"
+
+[[package]]
+name = "rustc_version"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92"
+dependencies = [
+ "semver",
+]
+
+[[package]]
+name = "rustls"
+version = "0.21.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f56a14d1f48b391359b22f731fd4bd7e43c97f3c50eee276f3aa09c94784d3e"
+dependencies = [
+ "log",
+ "ring",
+ "rustls-webpki 0.101.7",
+ "sct",
+]
+
+[[package]]
+name = "rustls"
+version = "0.23.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cd3c25631629d034ce7cd9940adc9d45762d46de2b0f57193c4443b92c6d4d40"
+dependencies = [
+ "aws-lc-rs",
+ "once_cell",
+ "rustls-pki-types",
+ "rustls-webpki 0.103.7",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "rustls-native-certs"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a9aace74cb666635c918e9c12bc0d348266037aa8eb599b5cba565709a8dff00"
+dependencies = [
+ "openssl-probe",
+ "rustls-pemfile",
+ "schannel",
+ "security-framework 2.11.1",
+]
+
+[[package]]
+name = "rustls-native-certs"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7fcff2dd52b58a8d98a70243663a0d234c4e2b79235637849d15913394a247d3"
+dependencies = [
+ "openssl-probe",
+ "rustls-pki-types",
+ "schannel",
+ "security-framework 3.5.1",
+]
+
+[[package]]
+name = "rustls-pemfile"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1c74cae0a4cf6ccbbf5f359f08efdf8ee7e1dc532573bf0db71968cb56b1448c"
+dependencies = [
+ "base64 0.21.7",
+]
+
+[[package]]
+name = "rustls-pki-types"
+version = "1.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "229a4a4c221013e7e1f1a043678c5cc39fe5171437c88fb47151a21e6f5b5c79"
+dependencies = [
+ "zeroize",
+]
+
+[[package]]
+name = "rustls-webpki"
+version = "0.101.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b6275d1ee7a1cd780b64aca7726599a1dbc893b1e64144529e55c3c2f745765"
+dependencies = [
+ "ring",
+ "untrusted",
+]
+
+[[package]]
+name = "rustls-webpki"
+version = "0.103.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e10b3f4191e8a80e6b43eebabfac91e5dcecebb27a71f04e820c47ec41d314bf"
+dependencies = [
+ "aws-lc-rs",
+ "ring",
+ "rustls-pki-types",
+ "untrusted",
+]
+
+[[package]]
+name = "rustversion"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"
+
+[[package]]
+name = "ryu"
+version = "1.0.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "28d3b2b1366ec20994f1fd18c3c594f05c5dd4bc44d8bb0c1c632c8d6829481f"
+
+[[package]]
+name = "schannel"
+version = "0.1.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "891d81b926048e76efe18581bf793546b4c0eaf8448d72be8de2bbee5fd166e1"
+dependencies = [
+ "windows-sys 0.61.1",
+]
+
+[[package]]
+name = "scopeguard"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
+
+[[package]]
+name = "sct"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da046153aa2352493d6cb7da4b6e5c0c057d8a1d0a9aa8560baffdd945acd414"
+dependencies = [
+ "ring",
+ "untrusted",
+]
+
+[[package]]
+name = "security-framework"
+version = "2.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "897b2245f0b511c87893af39b033e5ca9cce68824c4d7e7630b5a1d339658d02"
+dependencies = [
+ "bitflags",
+ "core-foundation 0.9.4",
+ "core-foundation-sys",
+ "libc",
+ "security-framework-sys",
+]
+
+[[package]]
+name = "security-framework"
+version = "3.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b3297343eaf830f66ede390ea39da1d462b6b0c1b000f420d0a83f898bbbe6ef"
+dependencies = [
+ "bitflags",
+ "core-foundation 0.10.1",
+ "core-foundation-sys",
+ "libc",
+ "security-framework-sys",
+]
+
+[[package]]
+name = "security-framework-sys"
+version = "2.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cc1f0cbffaac4852523ce30d8bd3c5cdc873501d96ff467ca09b6767bb8cd5c0"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
+[[package]]
+name = "semver"
+version = "1.0.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d767eb0aabc880b29956c35734170f26ed551a859dbd361d140cdbeca61ab1e2"
+
+[[package]]
+name = "serde"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
+dependencies = [
+ "serde_core",
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_core"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.145"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "402a6f66d8c709116cf22f558eab210f5a50187f702eb4d7e5ef38d9a7f1c79c"
+dependencies = [
+ "itoa",
+ "memchr",
+ "ryu",
+ "serde",
+ "serde_core",
+]
+
+[[package]]
+name = "sha2"
+version = "0.10.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
+[[package]]
+name = "shlex"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
+
+[[package]]
+name = "signal-hook-registry"
+version = "1.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b2a4719bff48cee6b39d12c020eeb490953ad2443b7055bd0b21fca26bd8c28b"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "slab"
+version = "0.4.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a2ae44ef20feb57a68b23d846850f861394c2e02dc425a50098ae8c90267589"
+
+[[package]]
+name = "smallvec"
+version = "1.15.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
+
+[[package]]
+name = "socket2"
+version = "0.5.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e22376abed350d73dd1cd119b57ffccad95b4e585a7cda43e286245ce23c0678"
+dependencies = [
+ "libc",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "socket2"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "233504af464074f9d066d7b5416c5f9b894a5862a6506e306f7b816cdd6f1807"
+dependencies = [
+ "libc",
+ "windows-sys 0.59.0",
+]
+
+[[package]]
+name = "stable_deref_trait"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3"
+
+[[package]]
+name = "subtle"
+version = "2.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
+
+[[package]]
+name = "syn"
+version = "2.0.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ede7c438028d4436d71104916910f5bb611972c5cfd7f89b8300a8186e6fada6"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "synstructure"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "time"
+version = "0.3.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91e7d9e3bb61134e77bde20dd4825b97c010155709965fedf0f49bb138e52a9d"
+dependencies = [
+ "deranged",
+ "num-conv",
+ "powerfmt",
+ "serde",
+ "time-core",
+ "time-macros",
+]
+
+[[package]]
+name = "time-core"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "40868e7c1d2f0b8d73e4a8c7f0ff63af4f6d19be117e90bd73eb1d62cf831c6b"
+
+[[package]]
+name = "time-macros"
+version = "0.2.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "30cfb0125f12d9c277f35663a0a33f8c30190f4e4574868a330595412d34ebf3"
+dependencies = [
+ "num-conv",
+ "time-core",
+]
+
+[[package]]
+name = "tinystr"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d4f6d1145dcb577acf783d4e601bc1d76a13337bb54e6233add580b07344c8b"
+dependencies = [
+ "displaydoc",
+ "zerovec",
+]
+
+[[package]]
+name = "tokio"
+version = "1.47.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "89e49afdadebb872d3145a5638b59eb0691ea23e46ca484037cfab3b76b95038"
+dependencies = [
+ "backtrace",
+ "bytes",
+ "io-uring",
+ "libc",
+ "mio",
+ "parking_lot",
+ "pin-project-lite",
+ "signal-hook-registry",
+ "slab",
+ "socket2 0.6.0",
+ "tokio-macros",
+ "windows-sys 0.59.0",
+]
+
+[[package]]
+name = "tokio-macros"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e06d43f1345a3bcd39f6a56dbb7dcab2ba47e68e8ac134855e7e2bdbaf8cab8"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "tokio-rustls"
+version = "0.24.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c28327cf380ac148141087fbfb9de9d7bd4e84ab5d2c28fbc911d753de8a7081"
+dependencies = [
+ "rustls 0.21.12",
+ "tokio",
+]
+
+[[package]]
+name = "tokio-rustls"
+version = "0.26.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1729aa945f29d91ba541258c8df89027d5792d85a8841fb65e8bf0f4ede4ef61"
+dependencies = [
+ "rustls 0.23.32",
+ "tokio",
+]
+
+[[package]]
+name = "tokio-util"
+version = "0.7.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "14307c986784f72ef81c89db7d9e28d6ac26d16213b109ea501696195e6e3ce5"
+dependencies = [
+ "bytes",
+ "futures-core",
+ "futures-sink",
+ "pin-project-lite",
+ "tokio",
+]
+
+[[package]]
+name = "tower"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d039ad9159c98b70ecfd540b2573b97f7f52c3e8d9f8ad57a24b916a536975f9"
+dependencies = [
+ "tower-layer",
+ "tower-service",
+]
+
+[[package]]
+name = "tower-layer"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "121c2a6cda46980bb0fcd1647ffaf6cd3fc79a013de288782836f6df9c48780e"
+
+[[package]]
+name = "tower-service"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8df9b6e13f2d32c91b9bd719c00d1958837bc7dec474d94952798cc8e69eeec3"
+
+[[package]]
+name = "tracing"
+version = "0.1.41"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "784e0ac535deb450455cbfa28a6f0df145ea1bb7ae51b821cf5e7927fdcfbdd0"
+dependencies = [
+ "pin-project-lite",
+ "tracing-attributes",
+ "tracing-core",
+]
+
+[[package]]
+name = "tracing-attributes"
+version = "0.1.30"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "81383ab64e72a7a8b8e13130c49e3dab29def6d0c7d76a03087b3cf71c5c6903"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "tracing-core"
+version = "0.1.34"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9d12581f227e93f094d3af2ae690a574abb8a2b9b7a96e7cfe9647b2b617678"
+dependencies = [
+ "once_cell",
+]
+
+[[package]]
+name = "try-lock"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b"
+
+[[package]]
+name = "typenum"
+version = "1.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "562d481066bde0658276a35467c4af00bdc6ee726305698a55b86e61d7ad82bb"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f63a545481291138910575129486daeaf8ac54aee4387fe7906919f7830c7d9d"
+
+[[package]]
+name = "untrusted"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
+
+[[package]]
+name = "url"
+version = "2.5.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08bc136a29a3d1758e07a9cca267be308aeebf5cfd5a10f3f67ab2097683ef5b"
+dependencies = [
+ "form_urlencoded",
+ "idna",
+ "percent-encoding",
+ "serde",
+]
+
+[[package]]
+name = "urlencoding"
+version = "2.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "daf8dba3b7eb870caf1ddeed7bc9d2a049f3cfdfae7cb521b087cc33ae4c49da"
+
+[[package]]
+name = "utf8_iter"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"
+
+[[package]]
+name = "uuid"
+version = "1.18.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2f87b8aa10b915a06587d0dec516c282ff295b475d94abf425d62b57710070a2"
+dependencies = [
+ "getrandom 0.3.3",
+ "js-sys",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "version_check"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+
+[[package]]
+name = "vsimd"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c3082ca00d5a5ef149bb8b555a72ae84c9c59f7250f013ac822ac2e49b19c64"
+
+[[package]]
+name = "want"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bfa7760aed19e106de2c7c0b581b509f2f25d3dacaf737cb82ac61bc6d760b0e"
+dependencies = [
+ "try-lock",
+]
+
+[[package]]
+name = "wasi"
+version = "0.11.1+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"
+
+[[package]]
+name = "wasi"
+version = "0.14.7+wasi-0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "883478de20367e224c0090af9cf5f9fa85bed63a95c1abf3afc5c083ebc06e8c"
+dependencies = [
+ "wasip2",
+]
+
+[[package]]
+name = "wasip2"
+version = "1.0.1+wasi-0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0562428422c63773dad2c345a1882263bbf4d65cf3f42e90921f787ef5ad58e7"
+dependencies = [
+ "wit-bindgen",
+]
+
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.104"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c1da10c01ae9f1ae40cbfac0bac3b1e724b320abfcf52229f80b547c0d250e2d"
+dependencies = [
+ "cfg-if",
+ "once_cell",
+ "rustversion",
+ "wasm-bindgen-macro",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-backend"
+version = "0.2.104"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "671c9a5a66f49d8a47345ab942e2cb93c7d1d0339065d4f8139c486121b43b19"
+dependencies = [
+ "bumpalo",
+ "log",
+ "proc-macro2",
+ "quote",
+ "syn",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.104"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7ca60477e4c59f5f2986c50191cd972e3a50d8a95603bc9434501cf156a9a119"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.104"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f07d2f20d4da7b26400c9f4a0511e6e0345b040694e8a75bd41d578fa4421d7"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+ "wasm-bindgen-backend",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.104"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bad67dc8b2a1a6e5448428adec4c3e84c43e561d8c9ee8a9e5aabeb193ec41d1"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "windows-link"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "45e46c0661abb7180e7b9c281db115305d49ca1709ab8242adf09666d2173c65"
+
+[[package]]
+name = "windows-sys"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
+dependencies = [
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.59.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
+dependencies = [
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.61.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6f109e41dd4a3c848907eb83d5a42ea98b3769495597450cf6d153507b166f0f"
+dependencies = [
+ "windows-link",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
+dependencies = [
+ "windows_aarch64_gnullvm 0.52.6",
+ "windows_aarch64_msvc 0.52.6",
+ "windows_i686_gnu 0.52.6",
+ "windows_i686_gnullvm 0.52.6",
+ "windows_i686_msvc 0.52.6",
+ "windows_x86_64_gnu 0.52.6",
+ "windows_x86_64_gnullvm 0.52.6",
+ "windows_x86_64_msvc 0.52.6",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.53.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2d42b7b7f66d2a06854650af09cfdf8713e427a439c97ad65a6375318033ac4b"
+dependencies = [
+ "windows-link",
+ "windows_aarch64_gnullvm 0.53.0",
+ "windows_aarch64_msvc 0.53.0",
+ "windows_i686_gnu 0.53.0",
+ "windows_i686_gnullvm 0.53.0",
+ "windows_i686_msvc 0.53.0",
+ "windows_x86_64_gnu 0.53.0",
+ "windows_x86_64_gnullvm 0.53.0",
+ "windows_x86_64_msvc 0.53.0",
+]
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "86b8d5f90ddd19cb4a147a5fa63ca848db3df085e25fee3cc10b39b6eebae764"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7651a1f62a11b8cbd5e0d42526e55f2c99886c77e007179efff86c2b137e66c"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c1dc67659d35f387f5f6c479dc4e28f1d4bb90ddd1a5d3da2e5d97b42d6272c3"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ce6ccbdedbf6d6354471319e781c0dfef054c81fbc7cf83f338a4296c0cae11"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "581fee95406bb13382d2f65cd4a908ca7b1e4c2f1917f143ba16efe98a589b5d"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2e55b5ac9ea33f2fc1716d1742db15574fd6fc8dadc51caab1c16a3d3b4190ba"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0a6e035dd0599267ce1ee132e51c27dd29437f63325753051e71dd9e42406c57"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "271414315aff87387382ec3d271b52d7ae78726f5d44ac98b4f4030c91880486"
+
+[[package]]
+name = "wit-bindgen"
+version = "0.46.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f17a85883d4e6d00e8a97c586de764dabcc06133f7f1d55dce5cdc070ad7fe59"
+
+[[package]]
+name = "writeable"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ea2f10b9bb0928dfb1b42b65e1f9e36f7f54dbdf08457afefb38afcdec4fa2bb"
+
+[[package]]
+name = "xmlparser"
+version = "0.13.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "66fee0b777b0f5ac1c69bb06d361268faafa61cd4682ae064a171c16c433e9e4"
+
+[[package]]
+name = "yoke"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f41bb01b8226ef4bfd589436a297c53d118f65921786300e427be8d487695cc"
+dependencies = [
+ "serde",
+ "stable_deref_trait",
+ "yoke-derive",
+ "zerofrom",
+]
+
+[[package]]
+name = "yoke-derive"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38da3c9736e16c5d3c8c597a9aaa5d1fa565d0532ae05e27c24aa62fb32c0ab6"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+ "synstructure",
+]
+
+[[package]]
+name = "zerofrom"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "50cc42e0333e05660c3587f3bf9d0478688e15d870fab3346451ce7f8c9fbea5"
+dependencies = [
+ "zerofrom-derive",
+]
+
+[[package]]
+name = "zerofrom-derive"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+ "synstructure",
+]
+
+[[package]]
+name = "zeroize"
+version = "1.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b97154e67e32c85465826e8bcc1c59429aaaf107c1e4a9e53c8d8ccd5eff88d0"
+
+[[package]]
+name = "zerotrie"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "36f0bbd478583f79edad978b407914f61b2972f5af6fa089686016be8f9af595"
+dependencies = [
+ "displaydoc",
+ "yoke",
+ "zerofrom",
+]
+
+[[package]]
+name = "zerovec"
+version = "0.11.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7aa2bd55086f1ab526693ecbe444205da57e25f4489879da80635a46d90e73b"
+dependencies = [
+ "yoke",
+ "zerofrom",
+ "zerovec-derive",
+]
+
+[[package]]
+name = "zerovec-derive"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b96237efa0c878c64bd89c436f661be4e46b2f3eff1ebb976f7ef2321d2f58f"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
diff --git a/crates/chat-exp/Cargo.toml b/crates/chat-exp/Cargo.toml
new file mode 100644
index 000000000..bed94bad2
--- /dev/null
+++ b/crates/chat-exp/Cargo.toml
@@ -0,0 +1,24 @@
+[package]
+name = "chat-exp2"
+version = "0.1.0"
+edition = "2021"
+
+[[bin]]
+name = "chat-exp2"
+path = "main.rs"
+
+[dependencies]
+tokio = { version = "1.0", features = ["full"] }
+tokio-util = "0.7"
+anyhow = "1.0"
+futures = "0.3"
+uuid = { version = "1.0", features = ["v4"] }
+
+# AWS SDK dependencies
+aws-sdk-bedrockruntime = "1.106.0"
+aws-config = "1.0"
+aws-credential-types = "1.0"
+serde_json = "1.0"
+
+# Async trait support
+async-trait = "0.1"
diff --git a/crates/chat-exp/main.md b/crates/chat-exp/main.md
new file mode 100644
index 000000000..dd1b9df28
--- /dev/null
+++ b/crates/chat-exp/main.md
@@ -0,0 +1,110 @@
+# AI Agent CLI Architecture Prototype
+
+## The Goals
+
+The primary goal of this architecture is to enable **multiple AI agents to run in parallel**, each working independently on different tasks while sharing common infrastructure. This design supports the core vision of having multiple specialized agents that can:
+
+- Execute different tasks simultaneously without blocking each other
+- Be configured independently with different parameters, tools, and behaviors
+- Share common resources (LLM providers, thread pools) efficiently
+- Be modified, added, or removed dynamically without affecting other agents
+
+The secondary goal is **extreme flexibility in agent configuration**. Each "Worker" (agent) can be customized with:
+- Different conversation contexts and histories
+- Unique tool sets and permissions
+- Specialized request builders and response handlers
+- Independent state management and error handling
+- Custom UI interfaces and interaction patterns
+
+More importantly, each "Worker" (agent) can run completely different tasks ("WorkerTask"), that implement different logic and behavior
+- General "Agent loop": LLM -> response -> Tools uses -> repeat
+- "/compact" and its variations
+- Orchestrator loop: (sub-agents states + available tasks) -> LLM -> (commands for sub-agents) -> repeat
+
+This architecture enables scenarios like having a code analysis agent running alongside a documentation agent, while an orchestrator agent coordinating their work - all operating concurrently with their own specialized configurations.
+
+## Core Elements
+
+### Worker
+The **Worker** represents a complete AI agent configuration - essentially "agent config JSON + conversation history + LLM access + tools" bundled into a single unit. Each Worker contains:
+- Unique ID and name for identification
+- Model provider for LLM communication
+- Thread-safe state management (Inactive, Working, Requesting, Receiving, Waiting, UsingTool, InactiveFailed)
+- Error tracking and failure handling
+- Not in this demo: conversation history, context resources, tools provider
+
+Workers are designed to be independent units that can be created, configured, and managed separately while sharing common infrastructure.
+
+### WorkerTask
+The **WorkerTask** trait defines the interface for executable work units. It abstracts different types of tasks that can be performed by a Worker:
+- Main agent conversation loops
+- Specialized commands (like `/compact`)
+- Custom sub-agent orchestration
+- Any finite agent operation
+
+Tasks are designed to be self-contained and cancellable, implementing a specific piece of work for a given Worker without handling user interaction directly.
+
+This is basically an interface for "Agent Loop", "Compact", and other kinds of tasks implementations.
+
+### WorkerJob
+The **WorkerJob** combines a Worker, a WorkerTask, and execution infrastructure into an active running unit. It manages:
+- The Worker performing the task
+- The specific WorkerTask being executed
+- Cancellation token for clean shutdown
+- Async task handle for the running operation
+
+This is Worker + Task + Running thread (tokio task handler) combination
+
+### Session
+The **Session** serves as the central orchestrator managing all Workers and Jobs. It provides:
+- Worker factory methods with shared model providers
+- Job launching and lifecycle management
+- Centralized cancellation for all running operations
+- Thread pool management for concurrent execution
+- Future: tools hosting, configuration management, conversation storage
+
+The Session ensures proper resource sharing while maintaining isolation between different agents.
+
+### WorkerToHostInterface
+The **WorkerToHostInterface** defines the communication contract between Workers and the UI layer. It handles:
+- State change notifications (worker transitions between states)
+- Response chunk streaming (real-time LLM output)
+- Tool confirmation requests (user approval for tool usage)
+- Cancellable user interactions
+
+This interface enables different UI implementations (CLI, web, API) to work with the same core Worker logic.
+
+This interface will be expanded to provide more communication ways, but the input must be business-centric, and not depend on choosen UI platform or framework.
+
+## Demo Elements
+
+### WorkerProtoLoop (Demo Task)
+The **WorkerProtoLoop** implements a demonstration WorkerTask that showcases the complete agent execution flow:
+1. **Working**: Prepares and builds the model request
+2. **Requesting**: Sends request to LLM provider
+3. **Receiving**: Streams response chunks to UI
+4. **Waiting**: Requests tool confirmation from user and then prints back user input
+5. **Inactive**: Completes successfully or transitions to InactiveFailed
+
+This demo task illustrates how real agent tasks would interact with the LLM, handle streaming responses, and coordinate with the UI layer.
+
+### CliInterface (Demo UI)
+The **CliInterface** provides a console-based implementation of WorkerToHostInterface:
+- Colored state change notifications for visual distinction
+- Real-time text streaming to stdout
+- Interactive user input with cancellation support
+- Color-coded output for multiple concurrent agents
+
+The CLI interface demonstrates how different UI implementations can provide distinct user experiences while using the same core architecture.
+
+### main() (Demo Application)
+The **main()** function orchestrates a complete demonstration of the architecture:
+1. **Initialization**: Creates Session with AWS Bedrock connectivity
+2. **Multi-Agent Setup**: Creates two Workers with different prompts and colors
+3. **Concurrent Execution**: Launches both agents simultaneously
+4. **Cancellation Demo**: Shows graceful shutdown after a timeout
+5. **State Inspection**: Displays final worker states for verification
+
+This demo proves the architecture's ability to handle multiple concurrent agents with independent configurations, shared resources, and coordinated lifecycle management.
+
+The demonstration showcases the key architectural benefits: agents running in parallel with different colors (Cyan and Green), different prompts ("lorem ipsum please, twice" vs "introduce yourself"), and independent state management while sharing the same Session infrastructure.
diff --git a/crates/chat-exp/main.rs b/crates/chat-exp/main.rs
new file mode 100644
index 000000000..212fb5fa9
--- /dev/null
+++ b/crates/chat-exp/main.rs
@@ -0,0 +1,942 @@
+use uuid::Uuid;
+use tokio_util::sync::CancellationToken;
+use tokio::io::{self, AsyncBufReadExt, BufReader};
+use aws_sdk_bedrockruntime::{Client as BedrockClient, types::{Message, ConversationRole, ContentBlock}};
+use aws_config::{BehaviorVersion, Region};
+use std::sync::{Arc, Mutex};
+use std::collections::HashMap;
+use std::pin::Pin;
+use std::future::Future;
+use tokio::sync::RwLock;
+
+// ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== //
+// =  ===   JOB CONTINUATION TYPES   ===  ===  ===  ===  ===  ===  ===  ===  = //
+// ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== //
+
+#[derive(Debug, Clone, Copy)]
+pub enum WorkerJobCompletionType {
+    Normal,
+    Cancelled,
+    Failed,
+}
+
+#[derive(Clone, Debug)]
+pub enum JobState {
+    Running,
+    Done(WorkerJobCompletionType, Option<String>), // Store error message as String instead of Result
+}
+
+pub type WorkerJobContinuationFn = Arc<
+    dyn Fn(Arc<Worker>, WorkerJobCompletionType, Option<String>) -> Pin<Box<dyn Future<Output = ()> + Send>>
+        + Send + Sync,
+>;
+
+pub struct Continuations {
+    state: RwLock<JobState>,
+    map: RwLock<HashMap<String, WorkerJobContinuationFn>>,
+}
+
+impl Continuations {
+    pub fn new() -> Self {
+        Self {
+            state: RwLock::new(JobState::Running),
+            map: RwLock::new(HashMap::new()),
+        }
+    }
+
+    pub fn boxed<F, Fut>(f: F) -> WorkerJobContinuationFn
+    where
+        F: Fn(Arc<Worker>, WorkerJobCompletionType, Option<String>) -> Fut + Send + Sync + 'static,
+        Fut: Future<Output = ()> + Send + 'static,
+    {
+        Arc::new(move |worker, completion_type, error_msg| Box::pin(f(worker, completion_type, error_msg)))
+    }
+
+    pub async fn add_or_run_now(&self, key: impl Into<String>, callback: WorkerJobContinuationFn, worker: Arc<Worker>) {
+        match &*self.state.read().await {
+            JobState::Running => {
+                self.map.write().await.insert(key.into(), callback);
+            }
+            JobState::Done(completion_type, error_msg) => {
+                let completion_type = *completion_type;
+                let error_msg = error_msg.clone();
+                tokio::spawn(callback(worker, completion_type, error_msg));
+            }
+        }
+    }
+
+    pub async fn complete(&self, result: Result<(), anyhow::Error>, worker: Arc<Worker>, cancellation_token: &CancellationToken) {
+        let completion_type = if cancellation_token.is_cancelled() {
+            WorkerJobCompletionType::Cancelled
+        } else if result.is_err() {
+            WorkerJobCompletionType::Failed
+        } else {
+            WorkerJobCompletionType::Normal
+        };
+
+        let error_msg = result.err().map(|e| e.to_string());
+
+        {
+            let mut st = self.state.write().await;
+            *st = JobState::Done(completion_type, error_msg.clone());
+        }
+        let callbacks = {
+            let mut map = self.map.write().await;
+            std::mem::take(&mut *map)
+        };
+        for (_name, cb) in callbacks {
+            let worker_clone = Arc::clone(&worker);
+            let error_msg_clone = error_msg.clone();
+            tokio::spawn(cb(worker_clone, completion_type, error_msg_clone));
+        }
+    }
+}
+
+// ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== //
+// =  ===   LLM ACCESS    ===  ===  ===  ===  ===  ===  ===  ===  ===  ===  = //
+// ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== //
+
+// Model Provider interface; request, stream, and response data structures
+// ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- //
+
+#[derive(Debug, Clone)]
+pub struct ModelRequest {
+    pub prompt: String,
+}
+
+#[derive(Debug, Clone)]
+pub enum ModelResponseChunk {
+    AssistantMessage(String),
+    ToolUseRequest { tool_name: String, parameters: String },
+}
+
+#[derive(Debug, Clone)]
+pub struct ModelResponse {
+    pub content: String,
+    pub tool_requests: Vec<ToolRequest>,
+}
+
+#[derive(Debug, Clone)]
+pub struct ToolRequest {
+    pub tool_name: String,
+    pub parameters: String,
+}
+
+#[async_trait::async_trait]
+pub trait ModelProvider: Send + Sync {
+    async fn request(
+        &self,
+        request: ModelRequest,
+        when_receiving_begin: impl Fn() + Send,
+        when_received: impl Fn(ModelResponseChunk) + Send,
+        cancellation_token: CancellationToken,
+    ) -> Result<ModelResponse, anyhow::Error>;
+}
+
+// Bedrock ConverseStream-based ModelProvider
+// ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- //
+
+#[derive(Clone)]
+pub struct BedrockConverseStreamModelProvider {
+    client: BedrockClient,
+    model_id: String,
+}
+
+impl BedrockConverseStreamModelProvider {
+    pub fn new(client: BedrockClient) -> Self {
+        Self {
+            client,
+            model_id: "us.anthropic.claude-sonnet-4-20250514-v1:0".to_string(),
+        }
+    }
+}
+
+#[async_trait::async_trait]
+impl ModelProvider for BedrockConverseStreamModelProvider {
+    async fn request(
+        &self,
+        request: ModelRequest,
+        when_receiving_begin: impl Fn() + Send,
+        when_received: impl Fn(ModelResponseChunk) + Send,
+        cancellation_token: CancellationToken,
+    ) -> Result<ModelResponse, anyhow::Error> {
+        let message = Message::builder()
+            .role(ConversationRole::User)
+            .content(ContentBlock::Text(request.prompt))
+            .build()?;
+
+        let response = tokio::select! {
+            result = self.client
+                .converse_stream()
+                .model_id(&self.model_id)
+                .messages(message)
+                .send() => {
+                match result {
+                    Ok(r) => r,
+                    Err(e) => {
+                        eprintln!("AWS Bedrock request failed:");
+                        eprintln!("  Model ID: {}", self.model_id);
+                        eprintln!("  Error type: {:?}", e);
+                        eprintln!("  Error message: {}", e);
+                        
+                        // Check for common error types
+                        if e.to_string().contains("dispatch failure") {
+                            eprintln!("  Likely causes:");
+                            eprintln!("    - AWS credentials not configured");
+                            eprintln!("    - Network connectivity issues");
+                            eprintln!("    - AWS region not set or incorrect");
+                            eprintln!("    - Bedrock service not available in region");
+                        }
+                        
+                        return Err(anyhow::anyhow!("Bedrock request failed: {}", e));
+                    }
+                }
+            },
+            _ = cancellation_token.cancelled() => {
+                return Err(anyhow::anyhow!("Request cancelled"));
+            }
+        };
+
+        when_receiving_begin();
+        let mut accumulated_content = String::new();
+        let mut stream = response.stream;
+
+        loop {
+            let event = tokio::select! {
+                event = stream.recv() => event,
+                _ = cancellation_token.cancelled() => {
+                    println!("Model request cancelled during streaming");
+                    return Err(anyhow::anyhow!("Request cancelled"));
+                }
+            };
+
+            match event {
+                Ok(Some(output)) => {
+                    // Check cancellation between processing chunks
+                    if cancellation_token.is_cancelled() {
+                        println!("Model request cancelled during chunk processing");
+                        return Err(anyhow::anyhow!("Request cancelled"));
+                    }
+                    
+                    match output {
+                        aws_sdk_bedrockruntime::types::ConverseStreamOutput::ContentBlockDelta(delta) => {
+                            if let Some(delta_content) = delta.delta {
+                                if let aws_sdk_bedrockruntime::types::ContentBlockDelta::Text(text) = delta_content {
+                                    accumulated_content.push_str(&text);
+                                    when_received(ModelResponseChunk::AssistantMessage(text));
+                                }
+                            }
+                        }
+                        aws_sdk_bedrockruntime::types::ConverseStreamOutput::MessageStop(_) => {
+                            break;
+                        }
+                        _ => {}
+                    }
+                }
+                Ok(None) => break,
+                Err(e) => return Err(anyhow::anyhow!("Stream error: {}", e)),
+            }
+        }
+
+        Ok(ModelResponse {
+            content: accumulated_content,
+            tool_requests: Vec::new(),
+        })
+    }
+}
+
+// ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== //
+// =  ===    WORKERS, TASKS, AND JOBS    ===  ===  ===  ===  ===  ===  ===  = //
+// ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== //
+
+// Worker - combination of everything an agent needs to execute tasks. Think of it
+//      as "agent config JSON + conversation history + LLM access + tools"
+//      - (not in this demo) Conversation history
+//      - (not in this demo) Context resources
+//      - (not in this demo) LLM Request builder (combine context, tools info,
+//          conversation, any extra info)
+//      - LLM Provider (provides access to given modev over given API)
+//      - (not in this demo) Tools Provider (a layer responsible for approval and 
+//          execution of the tools)
+//
+//      **The main reason** to have that all as a signle union unit is
+//        that we want to have _multiple_ workers in memory at the same time,
+//        working on different tasks using different context and tools
+//
+// ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- //
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum WorkerStates {
+    Inactive,
+    Working,
+    Requesting,
+    Receiving,
+    Waiting,
+    UsingTool,
+    InactiveFailed,
+}
+
+pub struct Worker {
+    pub id: Uuid,
+    pub name: String,
+    // + conversation history
+    // + context resources
+    // + request builder
+    pub model_provider: BedrockConverseStreamModelProvider,
+    // + tools provider
+    pub state: Arc<Mutex<WorkerStates>>,
+    pub last_failure: Arc<Mutex<Option<String>>>,
+}
+
+impl Worker {
+    pub fn new(name: String, model_provider: BedrockConverseStreamModelProvider) -> Self {
+        Self {
+            id: Uuid::new_v4(),
+            name,
+            model_provider,
+            state: Arc::new(Mutex::new(WorkerStates::Inactive)),
+            last_failure: Arc::new(Mutex::new(None)),
+        }
+    }
+
+    pub fn set_state(&self, new_state: WorkerStates, interface: &dyn WorkerToHostInterface) {
+        {
+            let mut state = self.state.lock().unwrap();
+            *state = new_state;
+        }
+        interface.worker_state_change(self.id, new_state);
+    }
+
+    pub fn get_state(&self) -> WorkerStates {
+        *self.state.lock().unwrap()
+    }
+
+    pub fn set_failure(&self, error: String) {
+        let mut failure = self.last_failure.lock().unwrap();
+        *failure = Some(error);
+    }
+
+    pub fn get_failure(&self) -> Option<String> {
+        self.last_failure.lock().unwrap().clone()
+    }
+}
+
+// Worker Task - main abstraction of a logical task implemented for a worker
+//   Think of "Implementation for '/compact'" or "Implementation for main agent loop"
+//   This is an interface for actula implementations of tasks that can be performed 
+//   for a worker. Basic loop for a conversation agent, compact, custom sub-agents
+//   orchestrator loop - they all will be implemented behind this trait.
+//
+//   An importnat note: implemented 'MainAgentLoopTask' would NOT include asking
+//   the user for next prompt, it's intended to implement a finite 'agent turn',
+//   loop LLM->Response->ToolUses->LLM, that breaks when response has no tool uses.
+//   Main app UI would have to obtain the prompt from the user and launch `MainAgentLoopTask`
+//   again for each prompt.
+//
+// ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- //
+
+#[async_trait::async_trait]
+pub trait WorkerTask: Send + Sync {
+    fn get_worker(&self) -> &Worker;
+    async fn run(&self) -> Result<(), anyhow::Error>;
+}
+
+// WorkerJob - an entry for an active task running for given WorkerTask
+// Basically WorkerTask + actual running task handle
+// ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- //
+
+pub struct WorkerJob {
+    pub worker: Arc<Worker>,
+    pub worker_task: Arc<dyn WorkerTask>,
+    pub cancellation_token: CancellationToken,
+    pub task_handle: Option<tokio::task::JoinHandle<Result<(), anyhow::Error>>>,
+    pub continuations: Arc<Continuations>,
+}
+
+impl WorkerJob {
+    pub fn new(
+        worker: Arc<Worker>,
+        worker_task: Arc<dyn WorkerTask>,
+        cancellation_token: CancellationToken,
+    ) -> Self {
+        Self {
+            worker,
+            worker_task,
+            cancellation_token,
+            task_handle: None,
+            continuations: Arc::new(Continuations::new()),
+        }
+    }
+
+    pub fn launch(&mut self) {
+        let worker_task_clone = self.worker_task.clone();
+        let continuations = Arc::clone(&self.continuations);
+        let worker = Arc::clone(&self.worker);
+        let cancellation_token = self.cancellation_token.clone();
+        
+        let task_handle = tokio::spawn(async move {
+            let result = worker_task_clone.run().await;
+            continuations.complete(result, worker, &cancellation_token).await;
+            Ok(()) // Always return Ok since we handle the error in complete()
+        });
+        self.task_handle = Some(task_handle);
+    }
+
+    pub fn cancel(&self) {
+        self.cancellation_token.cancel();
+    }
+
+    pub async fn wait(self) -> Result<(), anyhow::Error> {
+        match self.task_handle {
+            Some(handle) => match handle.await {
+                Ok(result) => result,
+                Err(join_error) => Err(anyhow::anyhow!("Task panicked: {}", join_error)),
+            },
+            None => Err(anyhow::anyhow!("Task not launched")),
+        }
+    }
+}
+
+
+// ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== //
+// =  ===   DEMO WORKER TASK   ===  ===  ===  ===  ===  ===  ===  ===  ===  = //
+// ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== //
+
+// Demo Prototype Worker Loop task
+//   This is just a demo. It queries LLM through ModelProvider, then uses
+//   WorkerToHostInterface.get_tool_confirmation to ask for input from the user
+//   and sends it back as a fake chunk from the model.
+// ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- //
+
+#[derive(Debug, Clone)]
+pub struct WorkerInput {
+    pub prompt: String,
+}
+
+pub struct WorkerProtoLoop {
+    worker: Arc<Worker>,
+    cancellation_token: CancellationToken,
+    input: WorkerInput,
+    host_interface: Arc<dyn WorkerToHostInterface>,
+}
+
+impl WorkerProtoLoop {
+    pub fn new(
+        worker: Arc<Worker>,
+        input: WorkerInput,
+        host_interface: Arc<dyn WorkerToHostInterface>,
+        cancellation_token: CancellationToken,
+    ) -> Self {
+        Self {
+            worker,
+            input,
+            host_interface,
+            cancellation_token,
+        }
+    }
+}
+
+#[async_trait::async_trait]
+impl WorkerTask for WorkerProtoLoop {
+    fn get_worker(&self) -> &Worker {
+        &self.worker
+    }
+
+    async fn run(&self) -> Result<(), anyhow::Error> {
+        // Reset worker state and start up
+        self.check_cancellation("before starting")?;
+        self.reset_worker();
+        
+        // demo request from a model
+        //      note: both request and UI callback a cancellable
+        let model_request = self.build_request();
+        let model_response = self.make_model_request(model_request).await?;
+
+        // demo callback to the UI
+        self.demo_tool_confirmation(model_response).await?;
+        
+        // finish
+        self.complete_successfully()
+    }
+}
+
+impl WorkerProtoLoop {
+    fn check_cancellation(&self, stage: &str) -> Result<(), anyhow::Error> {
+        if self.cancellation_token.is_cancelled() {
+            println!("Worker {} cancelled {}", self.worker.id, stage);
+            return Err(anyhow::anyhow!("Operation cancelled"));
+        }
+        Ok(())
+    }
+
+    fn reset_worker(&self) {
+        self.worker.set_failure("".to_string());
+        self.worker.set_state(WorkerStates::Working, &*self.host_interface);
+    }
+
+    fn build_request(&self) -> ModelRequest {
+        ModelRequest {
+            prompt: self.input.prompt.clone(),
+        }
+    }
+
+    async fn make_model_request(&self, model_request: ModelRequest) -> Result<ModelResponse, anyhow::Error> {
+        self.worker.set_state(WorkerStates::Requesting, &*self.host_interface);
+        
+        let response = self.worker.model_provider.request(
+            model_request,
+            || {
+                self.worker.set_state(WorkerStates::Receiving, &*self.host_interface);
+            },
+            |chunk| {
+                self.host_interface.response_chunk_received(self.worker.id, chunk);
+            },
+            self.cancellation_token.clone(),
+        ).await.map_err(|e| {
+            if !self.cancellation_token.is_cancelled() {
+                let error_msg = format!("Model request failed: {}", e);
+                eprintln!("Error in worker {}: {}", self.worker.id, error_msg);
+                self.worker.set_failure(error_msg);
+                self.worker.set_state(WorkerStates::InactiveFailed, &*self.host_interface);
+            } else {
+                self.worker.set_state(WorkerStates::Inactive, &*self.host_interface);
+            }
+            e
+        })?;
+        
+        Ok(response)
+    }
+
+    async fn demo_tool_confirmation(&self, model_response: ModelResponse) -> Result<(), anyhow::Error> {
+        self.check_cancellation("before tool confirmation")?;
+        self.worker.set_state(WorkerStates::Waiting, &*self.host_interface);
+        
+        let user_response = self.host_interface.get_tool_confirmation(
+            self.worker.id,
+            format!("Hello from worker! MR={}", 
+                model_response.content.chars().take(50).collect::<String>()),
+            self.cancellation_token.clone(),
+        ).await.map_err(|e| {
+            if !self.cancellation_token.is_cancelled() {
+                let error_msg = format!("Tool confirmation failed: {}", e);
+                eprintln!("Error in worker {}: {}", self.worker.id, error_msg);
+                self.worker.set_failure(error_msg);
+                self.worker.set_state(WorkerStates::InactiveFailed, &*self.host_interface);
+            } else {
+                self.worker.set_state(WorkerStates::Inactive, &*self.host_interface);
+            }
+            e
+        })?;
+        
+        // Publish user response as fake AssistantMessage chunk
+        self.host_interface.response_chunk_received(
+            self.worker.id,
+            ModelResponseChunk::AssistantMessage(format!("\n\nUser said: {}\n", user_response))
+        );
+        
+        Ok(())
+    }
+
+    fn complete_successfully(&self) -> Result<(), anyhow::Error> {
+        self.worker.set_state(WorkerStates::Inactive, &*self.host_interface);
+        println!("Worker {} completed successfully", self.worker.id);
+        Ok(())
+    }
+}
+
+// ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== //
+// = WorkerToHostInterface - primamry WoorkerTask <-> UI communication API  = //
+// ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== //
+
+// Note: get_tool_confirmation() API is simplified to demo an interruption for
+// external information request. **This is NOT** intented way to ask for user
+// prompt between agent turns. The production implementation would take ToolRequest,
+// and return either OK, NOT_OK(reason), or modified ToolRequest. It's going to be
+// up to UI how exactly to let user provide that response.
+
+#[async_trait::async_trait]
+pub trait WorkerToHostInterface: Send + Sync {
+    fn worker_state_change(&self, worker_id: Uuid, new_state: WorkerStates);
+    fn response_chunk_received(&self, worker_id: Uuid, chunk: ModelResponseChunk);
+    async fn get_tool_confirmation(
+        &self,
+        worker_id: Uuid,
+        request: String,
+        cancellation_token: CancellationToken,
+    ) -> Result<String, anyhow::Error>;
+}
+
+// ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== //
+// =  Session - the main orchestrator of runing Worker Tasks and Jobs  ===  = //
+// ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== //
+
+// Session maintains the lists of existing Workers and running Jobs
+//  .build_worker() creates new worker instance. It would be parametrised to build
+//      a worker based on provided configs, available tools, etc
+//  .run_xxx() is a shortcut to build a Task of specific class and launch it as a Job
+//  .run() internal method that actually launches provided Task as a Job
+//  .cancel_all_jobs() - triggers cancellation tokens for all available jobs
+//
+//  In production implementation it would have self-cleaning for `jobs` list, and APIs
+//  to remove workers that are no longer needed.
+
+pub struct Session {
+    model_providers: Vec<BedrockConverseStreamModelProvider>,
+    workers: Arc<Mutex<Vec<Arc<Worker>>>>,
+    jobs: Arc<Mutex<Vec<Arc<WorkerJob>>>>,
+}
+
+impl Session {
+    pub fn new(model_providers: Vec<BedrockConverseStreamModelProvider>) -> Self {
+        Self {
+            model_providers,
+            workers: Arc::new(Mutex::new(Vec::new())),
+            jobs: Arc::new(Mutex::new(Vec::new())),
+        }
+    }
+
+    pub fn build_worker(&self) -> Arc<Worker> {
+        let model_provider = self.model_providers.first()
+            .expect("At least one model provider required")
+            .clone();
+        
+        let worker = Arc::new(Worker::new(
+            "Test worker".to_string(),
+            model_provider,
+        ));
+        
+        self.workers.lock().unwrap().push(worker.clone());
+        worker
+    }
+
+    pub fn run_demo_loop(
+        &self,
+        worker: Arc<Worker>,
+        input: WorkerInput,
+        ui_interface: Arc<dyn WorkerToHostInterface>,
+    ) -> Result<Arc<WorkerJob>, anyhow::Error> {
+        let cancellation_token = CancellationToken::new();
+        
+        let worker_loop = Arc::new(WorkerProtoLoop::new(
+            worker.clone(),
+            input,
+            ui_interface,
+            cancellation_token.clone(),
+        ));
+        
+        self.run(worker, worker_loop, cancellation_token)
+    }
+
+    // Launching a Task - producing a Job
+    fn run(
+        &self,
+        worker: Arc<Worker>,
+        worker_task: Arc<dyn WorkerTask>,
+        cancellation_token: CancellationToken,
+    ) -> Result<Arc<WorkerJob>, anyhow::Error> {
+        let mut job = WorkerJob::new(
+            worker,
+            worker_task,
+            cancellation_token,
+        );
+        
+        job.launch();
+
+        let job = Arc::new(job);
+        self.jobs.lock().unwrap().push(job.clone());
+        Ok(job)
+    }
+
+    pub fn cancel_all_jobs(&self) {
+        let jobs = self.jobs.lock().unwrap();
+        for job in jobs.iter() {
+            job.cancel();
+        }
+    }
+}
+
+// ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== //
+// =    Demo CLI WorkerToHostInterface   ===  ===  ===  ===  ===  ===  ===  = //
+// ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== //
+
+// An example implementatoon that prints out response from the task in provided
+// terminal foreground color.
+
+pub struct CliInterface {
+    color_code: &'static str,
+}
+
+impl CliInterface {
+    pub fn new(color_code: &'static str) -> Self {
+        Self { color_code }
+    }
+}
+
+#[async_trait::async_trait]
+impl WorkerToHostInterface for CliInterface {
+    fn worker_state_change(&self, worker_id: Uuid, new_state: WorkerStates) {
+        println!("\r\n\x1b[31m[{}] Switched to state: {:?}\x1b[0m\r\n", worker_id, new_state);
+        
+        // Log failed states with error details
+        if new_state == WorkerStates::InactiveFailed {
+            eprintln!("\x1b[91m[{}] Worker failed - check error details\x1b[0m", worker_id);
+        }
+    }
+
+    fn response_chunk_received(&self, _worker_id: Uuid, chunk: ModelResponseChunk) {
+        match chunk {
+            ModelResponseChunk::AssistantMessage(text) => {
+                print!("{}{}\x1b[0m", self.color_code, text);
+                std::io::Write::flush(&mut std::io::stdout()).unwrap();
+            }
+            ModelResponseChunk::ToolUseRequest { tool_name, parameters } => {
+                print!("{}[Tool: {} - {}]\x1b[0m", self.color_code, tool_name, parameters);
+                std::io::Write::flush(&mut std::io::stdout()).unwrap();
+            }
+        }
+    }
+
+    async fn get_tool_confirmation(
+        &self,
+        worker_id: Uuid,
+        request: String,
+        cancellation_token: CancellationToken,
+    ) -> Result<String, anyhow::Error> {
+        println!("\r\n\x1b[33m[{}] Requested: {}\x1b[0m\r\n", worker_id, request);
+        
+        let stdin = io::stdin();
+        let mut reader = BufReader::new(stdin);
+        let mut line = String::new();
+        
+        tokio::select! {
+            // Fun fact: while tokio::select will complete when cancellation token it triuggered,
+            // reader.read_line in the next line won't, and it will wait for the user to click Enter
+            // It looks even more fun when two tasks/jobs requested confirmation - whoever asked first
+            // will get the first <Enter>.
+            // It has to be replaced with more adwanced TUI solution in production
+            result = reader.read_line(&mut line) => {
+                result?;
+                Ok(line.trim().to_string())
+            }
+            _ = cancellation_token.cancelled() => {
+                Err(anyhow::anyhow!("Operation cancelled"))
+            }
+        }
+    }
+}
+
+// CLI Interface constructor for the running demo app
+// ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- //
+//  Something wannabe like 'The Main Core UI Implementation' thing.
+//  Produces CliInterface's with different colors for different workers.
+
+#[derive(Debug, Clone)]
+pub enum AnsiColor {
+    White,
+    Red,
+    Green,
+    Yellow,
+    Blue,
+    Magenta,
+    Cyan,
+}
+
+impl AnsiColor {
+    fn to_ansi_code(&self) -> &'static str {
+        match self {
+            AnsiColor::White => "\x1b[37m",
+            AnsiColor::Red => "\x1b[31m",
+            AnsiColor::Green => "\x1b[32m",
+            AnsiColor::Yellow => "\x1b[33m",
+            AnsiColor::Blue => "\x1b[34m",
+            AnsiColor::Magenta => "\x1b[35m",
+            AnsiColor::Cyan => "\x1b[36m",
+        }
+    }
+}
+
+#[derive(Clone)]
+pub struct CliUi;
+
+impl CliUi {
+    pub fn new() -> Self {
+        Self
+    }
+    
+    pub fn interface(&self, color: AnsiColor) -> CliInterface {
+        CliInterface::new(color.to_ansi_code())
+    }
+
+    pub fn report_job_completion(&self, worker: Arc<Worker>, completion_type: WorkerJobCompletionType) -> impl Future<Output = ()> + Send {
+        let worker_id = worker.id;
+        async move {
+            match completion_type {
+                WorkerJobCompletionType::Normal => println!("CONTINUATION: Worker {} completed successfully", worker_id),
+                WorkerJobCompletionType::Cancelled => println!("CONTINUATION: Worker {} was cancelled", worker_id),
+                WorkerJobCompletionType::Failed => println!("CONTINUATION: Worker {} failed", worker_id),
+            }
+        }
+    }
+}
+
+// Initialization functions, stage0 builders
+// ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== //
+
+// "Build Session" here is basically "Build Single Model Provider"
+// Production implementation would need more underlying components, more
+// advanced logic, and so on
+pub async fn build_session() -> Result<Session, anyhow::Error> {
+    println!("Loading AWS configuration...");
+    let config = aws_config::defaults(BehaviorVersion::latest())
+        .region(Region::new("us-east-1"))
+        .load()
+        .await;
+    
+    // Log AWS configuration details
+    println!("AWS Configuration:");
+    println!("  Region: {:?}", config.region());
+    
+    if config.credentials_provider().is_some() {
+        println!("  Credentials provider: configured");
+    } else {
+        eprintln!("  Credentials provider: NOT FOUND");
+        eprintln!("  Please run: aws configure");
+        eprintln!("  Or set AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY");
+        return Err(anyhow::anyhow!("No AWS credentials provider found"));
+    }
+    
+    let bedrock_client = BedrockClient::new(&config);
+    println!("Bedrock client created successfully");
+    
+    let model_provider = BedrockConverseStreamModelProvider::new(bedrock_client);
+    let model_providers = vec![model_provider];
+    
+    Ok(Session::new(model_providers))
+}
+
+pub fn build_ui() -> CliUi {
+    CliUi::new()
+}
+
+fn print_all_workers(session: &Session) {
+    let workers = session.workers.lock().unwrap();
+    for worker in workers.iter() {
+        let state = worker.get_state();
+        let failure = worker.get_failure();
+        let failure_text = match failure {
+            Some(f) if !f.is_empty() => format!(" - {}", f),
+            _ => String::new(),
+        };
+        println!("  {} - {:?}{}", worker.id, state, failure_text);
+    }
+}
+
+// ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== //
+// =   DEMO PROTOTYPE `main`   ===  ===  ===  ===  ===  ===  ===  ===  ===  = //
+// ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== //
+//
+//  To try different behavior, modify prompts for the tasks to answer quicker
+//  or longer, and abort_delay_seconds to send cancellation sooner or later.
+//
+//      Example 'long' prompts: 'lorem ipsum please, twice', 'introduce yourself'
+//      Example 'quick' prompts: 'say hello', 'hi!'
+//
+
+#[tokio::main]
+async fn main() -> Result<(), anyhow::Error> {
+    println!("Starting AI CLI architecture demo...");
+
+    // STAGE 0: Initialization
+    
+    // Create Session object, initializes LLM connectivity
+    let session = match build_session().await {
+        Ok(s) => {
+            println!("Session initialized successfully");
+            s
+        }
+        Err(e) => {
+            eprintln!("Failed to initialize session: {}", e);
+            eprintln!("Please check your AWS credentials and network connection");
+            return Err(e);
+        }
+    };
+
+    // Create UI implementation
+    let ui = build_ui();
+    
+    // STAGE 1-1: Create a (default) worker
+
+    // Create new worker
+    let worker = session.build_worker();
+    println!("Worker #1 {} created", worker.id);
+    
+    // STAGE 1-2: Launch a demo task for the worker
+
+    // Launch a job, passing UI interface to deal with necessary communications
+    let job1 = session.run_demo_loop(
+        worker.clone(),
+        WorkerInput {
+            prompt: "lorem ipsum please, twice".to_string(),
+        },
+        Arc::new(ui.interface(AnsiColor::Cyan)),
+    )?;
+
+    // STAGE 2-1: Create another (default) worker
+
+    // Create new worker
+    let worker2 = session.build_worker();
+    println!("Worker #2 {} created", worker2.id);
+    
+    // STAGE 2-2: Launch a demo task for the worker
+
+    // Launch a job, passing UI interface to deal with necessary communications
+    let job2 = session.run_demo_loop(
+        worker2.clone(),
+        WorkerInput {
+            prompt: "introduce yourself".to_string(),
+        },
+        Arc::new(ui.interface(AnsiColor::Green)),
+    )?;
+
+    // Add continuations:
+    let ui_clone = ui.clone();
+    job1.continuations.add_or_run_now(
+        "completion_report",
+        Continuations::boxed(move |worker, completion_type, _error_msg| ui_clone.report_job_completion(worker, completion_type)),
+        job1.worker.clone(),
+    ).await;
+
+    let ui_clone = ui.clone();
+    job2.continuations.add_or_run_now(
+        "completion_report", 
+        Continuations::boxed(move |worker, completion_type, _error_msg| ui_clone.report_job_completion(worker, completion_type)),
+        job2.worker.clone(),
+    ).await;
+    
+    // STAGE 3: Force abort the task after a delay
+
+    let abort_delay_seconds = 15;
+    println!("Job started, running for {} seconds...", abort_delay_seconds);
+    tokio::time::sleep(tokio::time::Duration::from_secs(abort_delay_seconds)).await;
+    
+    // Cancel all jobs by triggering cancellation token
+
+    println!("Workers BEFORE cancellation:");
+    print_all_workers(&session);
+
+    println!("Cancelling all jobs...");
+    session.cancel_all_jobs();
+
+    println!("Workers RIGHT AFTER cancellation:");
+    print_all_workers(&session);
+
+    // STAGE 4: Verify final state
+    
+    // Check all workers status after 1 second delay
+    tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
+    println!("Workers LATE AFTER cancellation:");
+    print_all_workers(&session);
+    
+    println!("Application completed successfully");
+    Ok(())
+}
diff --git a/web/public/app.js b/web/public/app.js
new file mode 100644
index 000000000..266ac1656
--- /dev/null
+++ b/web/public/app.js
@@ -0,0 +1,684 @@
+// ============================================================================
+// State Management Classes
+// ============================================================================
+
+/**
+ * Worker data model
+ */
+class WorkerData {
+    constructor(id, name, agent, state, currentJobId = null) {
+        this.id = id;
+        this.name = name;
+        this.agent = agent;
+        this.state = state;  // idle, busy, idle_failed
+        this.currentJobId = currentJobId;
+    }
+}
+
+/**
+ * Application state management
+ */
+class WebUIState {
+    constructor() {
+        this.workers = new Map();  // worker_id -> WorkerData
+        this.selectedWorkerId = null;
+        this.conversations = new Map();  // worker_id -> ConversationEntry[]
+        this.activeResponses = new Map();  // worker_id -> accumulated text
+        this.connectionState = 'disconnected';  // disconnected, connecting, connected
+    }
+    
+    // Worker management
+    addWorker(worker) {
+        this.workers.set(worker.id, worker);
+    }
+    
+    removeWorker(workerId) {
+        this.workers.delete(workerId);
+        this.conversations.delete(workerId);
+        this.activeResponses.delete(workerId);
+    }
+    
+    updateWorkerState(workerId, newState) {
+        const worker = this.workers.get(workerId);
+        if (worker) {
+            worker.state = newState;
+        }
+    }
+    
+    // Worker selection
+    selectWorker(workerId) {
+        this.selectedWorkerId = workerId;
+    }
+    
+    getSelectedWorker() {
+        return this.workers.get(this.selectedWorkerId);
+    }
+    
+    // Conversation management
+    setConversation(workerId, entries) {
+        this.conversations.set(workerId, entries);
+    }
+    
+    appendConversationEntry(workerId, entry) {
+        const conversation = this.conversations.get(workerId) || [];
+        conversation.push(entry);
+        this.conversations.set(workerId, conversation);
+    }
+    
+    getConversation(workerId) {
+        return this.conversations.get(workerId) || [];
+    }
+}
+
+// ============================================================================
+// WebSocket Client
+// ============================================================================
+
+/**
+ * WebSocket client with reconnection logic
+ */
+class WebSocketClient {
+    constructor(app) {
+        this.app = app;
+        this.ws = null;
+        this.reconnectAttempts = 0;
+        this.maxReconnectAttempts = 5;
+        this.reconnectDelay = 1000;  // ms
+    }
+    
+    connect() {
+        this.app.state.connectionState = 'connecting';
+        this.ws = new WebSocket(`ws://${window.location.host}/ws`);
+        
+        this.ws.onopen = () => {
+            console.log('WebSocket connected');
+            this.app.state.connectionState = 'connected';
+            this.reconnectAttempts = 0;
+            this.app.onConnected();
+        };
+        
+        this.ws.onmessage = (event) => {
+            const data = JSON.parse(event.data);
+            this.app.handleEvent(data);
+        };
+        
+        this.ws.onerror = (error) => {
+            console.error('WebSocket error:', error);
+        };
+        
+        this.ws.onclose = () => {
+            console.log('WebSocket closed');
+            this.app.state.connectionState = 'disconnected';
+            this.reconnect();
+        };
+    }
+    
+    reconnect() {
+        if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+            console.error('Max reconnection attempts reached');
+            return;
+        }
+        
+        this.reconnectAttempts++;
+        const delay = this.reconnectDelay * this.reconnectAttempts;
+        
+        console.log(`Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts})`);
+        setTimeout(() => this.connect(), delay);
+    }
+    
+    send(command) {
+        if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+            this.ws.send(JSON.stringify(command));
+        } else {
+            console.error('WebSocket not connected');
+        }
+    }
+}
+
+// ============================================================================
+// UI Components
+// ============================================================================
+
+/**
+ * Worker list sidebar component
+ */
+class WorkerList {
+    constructor(app) {
+        this.app = app;
+        this.element = document.getElementById('worker-list');
+    }
+    
+    render() {
+        const workers = Array.from(this.app.state.workers.values());
+        
+        this.element.innerHTML = workers
+            .map(w => this.renderWorker(w))
+            .join('');
+        
+        // Add event listeners
+        this.element.querySelectorAll('.worker-item').forEach(item => {
+            item.addEventListener('click', (e) => {
+                const workerId = e.currentTarget.dataset.workerId;
+                this.app.selectWorker(workerId);
+            });
+        });
+    }
+    
+    renderWorker(worker) {
+        const icon = this.getStateIcon(worker.state);
+        const active = worker.id === this.app.state.selectedWorkerId ? 'active' : '';
+        
+        return `
+            <div class="worker-item ${active}" data-worker-id="${worker.id}">
+                <span class="worker-icon">${icon}</span>
+                <div class="worker-info">
+                    <div class="worker-name">${this.escapeHtml(worker.name)}</div>
+                    <div class="worker-state">${worker.state}</div>
+                </div>
+            </div>
+        `;
+    }
+    
+    getStateIcon(state) {
+        switch (state) {
+            case 'idle': return '●';
+            case 'busy': return '⚙';
+            case 'idle_failed': return '✗';
+            default: return '?';
+        }
+    }
+    
+    escapeHtml(text) {
+        const div = document.createElement('div');
+        div.textContent = text;
+        return div.innerHTML;
+    }
+}
+
+/**
+ * Conversation view component
+ */
+class ConversationView {
+    constructor(app) {
+        this.app = app;
+        this.element = document.getElementById('conversation');
+    }
+    
+    render() {
+        const workerId = this.app.state.selectedWorkerId;
+        if (!workerId) {
+            this.element.innerHTML = '<div class="no-worker">Select a worker to view conversation</div>';
+            return;
+        }
+        
+        const entries = this.app.state.getConversation(workerId);
+        this.element.innerHTML = entries
+            .map(e => this.renderEntry(e))
+            .join('');
+        
+        this.scrollToBottom();
+    }
+    
+    renderEntry(entry) {
+        const bubbleClass = this.getBubbleClass(entry.type);
+        const content = this.formatContent(entry);
+        
+        return `
+            <div class="bubble ${bubbleClass}">
+                ${this.escapeHtml(content)}
+            </div>
+        `;
+    }
+    
+    getBubbleClass(type) {
+        switch (type) {
+            case 'user_message': return 'bubble-user';
+            case 'assistant_message': return 'bubble-assistant';
+            case 'tool_use': return 'bubble-tool';
+            case 'error': return 'bubble-error';
+            default: return 'bubble-default';
+        }
+    }
+    
+    formatContent(entry) {
+        if (entry.type === 'tool_use') {
+            const tools = entry.tool_uses
+                .map(t => `${t.tool_name}(${JSON.stringify(t.tool_input)})`)
+                .join(', ');
+            return `${entry.content}\n\nTools: ${tools}`;
+        }
+        return entry.content;
+    }
+    
+    appendEntry(entry) {
+        const html = this.renderEntry(entry);
+        this.element.insertAdjacentHTML('beforeend', html);
+        this.scrollToBottom();
+    }
+    
+    updateLastEntry(content) {
+        const lastBubble = this.element.lastElementChild;
+        if (lastBubble) {
+            lastBubble.textContent = content;
+        }
+    }
+    
+    scrollToBottom() {
+        this.element.scrollTop = this.element.scrollHeight;
+    }
+    
+    escapeHtml(text) {
+        const div = document.createElement('div');
+        div.textContent = text;
+        return div.innerHTML;
+    }
+}
+
+/**
+ * Input area component
+ */
+class InputArea {
+    constructor(app) {
+        this.app = app;
+        this.input = document.getElementById('prompt-input');
+        this.sendButton = document.getElementById('send-button');
+        this.cancelButton = document.getElementById('cancel-button');
+        
+        this.setupEventListeners();
+    }
+    
+    setupEventListeners() {
+        this.sendButton.addEventListener('click', () => this.sendMessage());
+        
+        this.input.addEventListener('keydown', (e) => {
+            if (e.key === 'Enter' && !e.shiftKey) {
+                e.preventDefault();
+                this.sendMessage();
+            }
+        });
+        
+        this.cancelButton.addEventListener('click', () => this.cancelJob());
+    }
+    
+    sendMessage() {
+        const text = this.input.value.trim();
+        if (!text) return;
+        
+        const workerId = this.app.state.selectedWorkerId;
+        if (!workerId) {
+            alert('Please select a worker');
+            return;
+        }
+        
+        // Add user message to conversation immediately
+        const userEntry = {
+            type: 'user_message',
+            content: text,
+            timestamp: Date.now() / 1000,
+        };
+        this.app.state.appendConversationEntry(workerId, userEntry);
+        this.app.components.conversationView.appendEntry(userEntry);
+        
+        this.app.ws.send({
+            type: 'prompt',
+            worker_id: workerId,
+            text: text,
+        });
+        
+        this.input.value = '';
+    }
+    
+    cancelJob() {
+        const workerId = this.app.state.selectedWorkerId;
+        if (!workerId) return;
+        
+        this.app.ws.send({
+            type: 'cancel',
+            worker_id: workerId,
+        });
+    }
+    
+    updateState() {
+        const worker = this.app.state.getSelectedWorker();
+        const isBusy = worker && worker.state === 'busy';
+        
+        this.input.disabled = isBusy;
+        this.sendButton.disabled = isBusy;
+        this.cancelButton.style.display = isBusy ? 'inline-block' : 'none';
+    }
+}
+
+/**
+ * New worker dialog component
+ */
+class NewWorkerDialog {
+    constructor(app) {
+        this.app = app;
+        this.dialog = document.getElementById('new-worker-dialog');
+        this.form = document.getElementById('new-worker-form');
+        this.nameInput = document.getElementById('worker-name-input');
+        this.agentInput = document.getElementById('worker-agent-input');
+        this.workingDirInput = document.getElementById('worker-workdir-input');
+        this.createButton = document.getElementById('create-worker-button');
+        this.cancelButton = document.getElementById('cancel-dialog-button');
+        
+        this.setupEventListeners();
+    }
+    
+    setupEventListeners() {
+        this.createButton.addEventListener('click', () => this.createWorker());
+        this.cancelButton.addEventListener('click', () => this.close());
+        
+        this.form.addEventListener('submit', (e) => {
+            e.preventDefault();
+            this.createWorker();
+        });
+        
+        // Close on outside click
+        this.dialog.addEventListener('click', (e) => {
+            if (e.target === this.dialog) {
+                this.close();
+            }
+        });
+    }
+    
+    show() {
+        this.dialog.style.display = 'flex';
+        this.agentInput.focus();
+    }
+    
+    close() {
+        this.dialog.style.display = 'none';
+        this.form.reset();
+    }
+    
+    createWorker() {
+        const agent = this.agentInput.value.trim();
+        if (!agent) {
+            alert('Agent name is required');
+            return;
+        }
+        
+        this.app.ws.send({
+            type: 'create_worker',
+            name: this.nameInput.value.trim() || null,
+            agent: agent,
+            working_directory: this.workingDirInput.value.trim() || null,
+        });
+        
+        this.close();
+    }
+}
+
+// ============================================================================
+// Response Accumulator
+// ============================================================================
+
+/**
+ * Accumulates streaming response chunks into single bubbles
+ */
+class ResponseAccumulator {
+    constructor(app) {
+        this.app = app;
+        this.activeResponses = new Map();  // worker_id -> ResponseState
+    }
+    
+    handleChunk(event) {
+        const { worker_id, chunk } = event;
+        
+        if (chunk.chunk_type === 'assistant_response') {
+            this.handleAssistantChunk(worker_id, chunk.text);
+        } else if (chunk.chunk_type === 'tool_use') {
+            this.handleToolUseChunk(worker_id, chunk);
+        } else if (chunk.chunk_type === 'tool_result') {
+            this.handleToolResultChunk(worker_id, chunk);
+        }
+    }
+    
+    handleAssistantChunk(workerId, text) {
+        if (!this.activeResponses.has(workerId)) {
+            // Start new response
+            const entry = {
+                type: 'assistant_message',
+                content: text,
+                timestamp: Date.now() / 1000,
+            };
+            
+            this.activeResponses.set(workerId, {
+                entry: entry,
+                startTime: Date.now(),
+            });
+            
+            // Create bubble in UI if this is the selected worker
+            if (workerId === this.app.state.selectedWorkerId) {
+                this.app.components.conversationView.appendEntry(entry);
+            }
+        } else {
+            // Append to existing response
+            const state = this.activeResponses.get(workerId);
+            state.entry.content += text;
+            
+            // Update bubble in UI if this is the selected worker
+            if (workerId === this.app.state.selectedWorkerId) {
+                this.app.components.conversationView.updateLastEntry(state.entry.content);
+            }
+        }
+    }
+    
+    handleToolUseChunk(workerId, chunk) {
+        // Tool use is typically sent as single chunk, not streamed
+        const entry = {
+            type: 'tool_use',
+            content: 'Using tool...',
+            tool_uses: [{
+                tool_name: chunk.tool_name,
+                tool_input: chunk.tool_input,
+            }],
+            timestamp: Date.now() / 1000,
+        };
+        
+        if (workerId === this.app.state.selectedWorkerId) {
+            this.app.components.conversationView.appendEntry(entry);
+        }
+        
+        this.app.state.appendConversationEntry(workerId, entry);
+    }
+    
+    handleToolResultChunk(workerId, chunk) {
+        // Tool result is typically sent as single chunk
+        const entry = {
+            type: 'tool_result',
+            content: `Tool ${chunk.tool_name} result: ${chunk.result}`,
+            timestamp: Date.now() / 1000,
+        };
+        
+        if (workerId === this.app.state.selectedWorkerId) {
+            this.app.components.conversationView.appendEntry(entry);
+        }
+        
+        this.app.state.appendConversationEntry(workerId, entry);
+    }
+    
+    finalize(workerId) {
+        // Called on JobCompleted
+        const state = this.activeResponses.get(workerId);
+        if (state) {
+            // Add to conversation history
+            this.app.state.appendConversationEntry(workerId, state.entry);
+            
+            // Clear active response
+            this.activeResponses.delete(workerId);
+        }
+    }
+}
+
+// ============================================================================
+// Main Application
+// ============================================================================
+
+/**
+ * Main application class
+ */
+class WebUIApp {
+    constructor() {
+        this.state = new WebUIState();
+        this.ws = new WebSocketClient(this);
+        this.components = {
+            workerList: new WorkerList(this),
+            conversationView: new ConversationView(this),
+            inputArea: new InputArea(this),
+            newWorkerDialog: new NewWorkerDialog(this),
+        };
+        this.accumulator = new ResponseAccumulator(this);
+    }
+    
+    async init() {
+        this.setupGlobalEventListeners();
+        await this.ws.connect();
+    }
+    
+    setupGlobalEventListeners() {
+        document.getElementById('new-worker-button').addEventListener('click', () => {
+            this.components.newWorkerDialog.show();
+        });
+    }
+    
+    onConnected() {
+        // Initial snapshots are sent automatically by server
+        console.log('Connected, waiting for initial snapshots');
+    }
+    
+    selectWorker(workerId) {
+        this.state.selectWorker(workerId);
+        
+        // Request conversation history if not loaded
+        if (!this.state.conversations.has(workerId)) {
+            this.ws.send({
+                type: 'get_conversation_history',
+                worker_id: workerId,
+            });
+        }
+        
+        this.components.workerList.render();
+        this.components.conversationView.render();
+        this.components.inputArea.updateState();
+    }
+    
+    handleEvent(event) {
+        console.log('Event received:', event.type);
+        
+        switch (event.type) {
+            case 'workers_snapshot':
+                this.handleWorkersSnapshot(event);
+                break;
+            case 'conversation_snapshot':
+                this.handleConversationSnapshot(event);
+                break;
+            case 'worker_created':
+                this.handleWorkerCreated(event);
+                break;
+            case 'worker_state_changed':
+                this.handleWorkerStateChanged(event);
+                break;
+            case 'output_chunk':
+                this.accumulator.handleChunk(event);
+                break;
+            case 'job_started':
+                this.handleJobStarted(event);
+                break;
+            case 'job_completed':
+                this.handleJobCompleted(event);
+                break;
+            case 'error':
+                this.handleError(event);
+                break;
+            default:
+                console.log('Unhandled event type:', event.type);
+        }
+    }
+    
+    handleWorkersSnapshot(event) {
+        event.workers.forEach(w => {
+            this.state.addWorker(new WorkerData(
+                w.id, w.name, w.agent, w.state, null
+            ));
+        });
+        
+        // Auto-select first worker if none selected
+        if (!this.state.selectedWorkerId && event.workers.length > 0) {
+            this.selectWorker(event.workers[0].id);
+        }
+        
+        this.components.workerList.render();
+    }
+    
+    handleConversationSnapshot(event) {
+        this.state.setConversation(event.worker_id, event.entries);
+        
+        if (event.worker_id === this.state.selectedWorkerId) {
+            this.components.conversationView.render();
+        }
+    }
+    
+    handleWorkerCreated(event) {
+        this.state.addWorker(new WorkerData(
+            event.worker_id, event.name, 'default', 'idle', null
+        ));
+        this.components.workerList.render();
+        
+        // Auto-select new worker
+        this.selectWorker(event.worker_id);
+    }
+    
+    handleWorkerStateChanged(event) {
+        this.state.updateWorkerState(event.worker_id, event.new_state);
+        this.components.workerList.render();
+        this.components.inputArea.updateState();
+    }
+    
+    handleJobStarted(event) {
+        const worker = this.state.workers.get(event.worker_id);
+        if (worker) {
+            worker.currentJobId = event.job_id;
+        }
+        this.components.inputArea.updateState();
+    }
+    
+    handleJobCompleted(event) {
+        const worker = this.state.workers.get(event.worker_id);
+        if (worker) {
+            worker.currentJobId = null;
+        }
+        this.accumulator.finalize(event.worker_id);
+        
+        // Display error message if job failed
+        if (event.result.status === 'failed') {
+            const errorEntry = {
+                type: 'error',
+                content: event.result.error,
+                timestamp: event.timestamp,
+            };
+            this.state.appendConversationEntry(event.worker_id, errorEntry);
+            if (event.worker_id === this.state.selectedWorkerId) {
+                this.components.conversationView.appendEntry(errorEntry);
+            }
+        }
+        
+        this.components.inputArea.updateState();
+    }
+    
+    handleError(event) {
+        alert(`Error: ${event.message}`);
+        console.error('Command error:', event);
+    }
+}
+
+// ============================================================================
+// Initialize app on page load
+// ============================================================================
+
+let app;
+document.addEventListener('DOMContentLoaded', () => {
+    app = new WebUIApp();
+    app.init();
+});
diff --git a/web/public/index.html b/web/public/index.html
new file mode 100644
index 000000000..e6f5c5ac7
--- /dev/null
+++ b/web/public/index.html
@@ -0,0 +1,64 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Q CLI - Web UI</title>
+    <link rel="stylesheet" href="style.css">
+</head>
+<body>
+    <div class="container">
+        <!-- Sidebar -->
+        <aside class="sidebar">
+            <div class="sidebar-header">
+                <h2>Workers</h2>
+                <button id="new-worker-button" class="btn-new">+ New</button>
+            </div>
+            <div id="worker-list" class="worker-list"></div>
+        </aside>
+        
+        <!-- Main Content -->
+        <main class="main-content">
+            <header class="content-header">
+                <h1 id="worker-title">Q CLI - Web UI</h1>
+                <div id="connection-status" class="connection-status"></div>
+            </header>
+            
+            <div id="conversation" class="conversation"></div>
+            
+            <div class="input-area">
+                <textarea id="prompt-input" placeholder="Type your message..." rows="3"></textarea>
+                <button id="send-button" class="btn-send">Send</button>
+                <button id="cancel-button" class="btn-cancel" style="display: none;">Cancel</button>
+            </div>
+        </main>
+    </div>
+    
+    <!-- New Worker Dialog -->
+    <div id="new-worker-dialog" class="dialog" style="display: none;">
+        <div class="dialog-content">
+            <h2>Create New Worker</h2>
+            <form id="new-worker-form">
+                <label>
+                    Worker Name (optional):
+                    <input type="text" id="worker-name-input" placeholder="auto-generated">
+                </label>
+                <label>
+                    Agent Name:
+                    <input type="text" id="worker-agent-input" placeholder="default" required>
+                </label>
+                <label>
+                    Working Directory (optional):
+                    <input type="text" id="worker-workdir-input" placeholder="~/">
+                </label>
+                <div class="dialog-buttons">
+                    <button type="submit" id="create-worker-button" class="btn-primary">Create</button>
+                    <button type="button" id="cancel-dialog-button" class="btn-secondary">Cancel</button>
+                </div>
+            </form>
+        </div>
+    </div>
+    
+    <script src="app.js"></script>
+</body>
+</html>
diff --git a/web/public/style.css b/web/public/style.css
new file mode 100644
index 000000000..c5fda89de
--- /dev/null
+++ b/web/public/style.css
@@ -0,0 +1,394 @@
+/* ============================================================================
+   Global Styles
+   ============================================================================ */
+
+* {
+    margin: 0;
+    padding: 0;
+    box-sizing: border-box;
+}
+
+body {
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, sans-serif;
+    font-size: 14px;
+    line-height: 1.5;
+    color: #333;
+    background-color: #fff;
+}
+
+/* ============================================================================
+   Container Layout
+   ============================================================================ */
+
+.container {
+    display: flex;
+    height: 100vh;
+    overflow: hidden;
+}
+
+/* ============================================================================
+   Sidebar
+   ============================================================================ */
+
+.sidebar {
+    width: 250px;
+    background-color: #f5f5f5;
+    border-right: 1px solid #ddd;
+    display: flex;
+    flex-direction: column;
+}
+
+.sidebar-header {
+    padding: 16px;
+    border-bottom: 1px solid #ddd;
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+}
+
+.sidebar-header h2 {
+    font-size: 18px;
+    font-weight: 600;
+}
+
+.btn-new {
+    padding: 6px 12px;
+    background-color: #007bff;
+    color: white;
+    border: none;
+    border-radius: 4px;
+    cursor: pointer;
+    font-size: 14px;
+}
+
+.btn-new:hover {
+    background-color: #0056b3;
+}
+
+.worker-list {
+    flex: 1;
+    overflow-y: auto;
+    padding: 8px;
+}
+
+.worker-item {
+    display: flex;
+    align-items: center;
+    padding: 12px;
+    margin-bottom: 4px;
+    border-radius: 6px;
+    cursor: pointer;
+    transition: background-color 0.2s;
+}
+
+.worker-item:hover {
+    background-color: #e9ecef;
+}
+
+.worker-item.active {
+    background-color: #007bff;
+    color: white;
+}
+
+.worker-icon {
+    font-size: 20px;
+    margin-right: 12px;
+}
+
+.worker-info {
+    flex: 1;
+}
+
+.worker-name {
+    font-weight: 500;
+    font-size: 14px;
+}
+
+.worker-state {
+    font-size: 12px;
+    opacity: 0.8;
+}
+
+/* ============================================================================
+   Main Content
+   ============================================================================ */
+
+.main-content {
+    flex: 1;
+    display: flex;
+    flex-direction: column;
+    background-color: #fff;
+}
+
+.content-header {
+    padding: 16px 24px;
+    border-bottom: 1px solid #ddd;
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+}
+
+.content-header h1 {
+    font-size: 20px;
+    font-weight: 600;
+}
+
+.connection-status {
+    font-size: 12px;
+    color: #666;
+}
+
+/* ============================================================================
+   Conversation Area
+   ============================================================================ */
+
+.conversation {
+    flex: 1;
+    overflow-y: auto;
+    padding: 24px;
+    display: flex;
+    flex-direction: column;
+    gap: 12px;
+}
+
+.no-worker {
+    text-align: center;
+    color: #999;
+    padding: 48px;
+    font-size: 16px;
+}
+
+/* ============================================================================
+   Chat Bubbles
+   ============================================================================ */
+
+.bubble {
+    max-width: 80%;
+    padding: 12px 16px;
+    border-radius: 12px;
+    word-wrap: break-word;
+    white-space: pre-wrap;
+}
+
+.bubble-user {
+    align-self: flex-end;
+    background-color: #e3f2fd;
+    border: 1px solid #90caf9;
+    color: #1565c0;
+}
+
+.bubble-assistant {
+    align-self: flex-start;
+    max-width: 100%;
+    background-color: transparent;
+    border: 1px solid #aed581;
+    color: #33691e;
+}
+
+.bubble-tool {
+    align-self: flex-start;
+    background-color: #fff3e0;
+    border: 1px solid #ffb74d;
+    color: #e65100;
+}
+
+.bubble-error {
+    align-self: flex-start;
+    background-color: #ffebee;
+    border: 1px solid #ef5350;
+    color: #c62828;
+}
+
+.bubble-default {
+    align-self: flex-start;
+    background-color: #f5f5f5;
+    border: 1px solid #ddd;
+    color: #333;
+}
+
+/* ============================================================================
+   Input Area
+   ============================================================================ */
+
+.input-area {
+    padding: 16px 24px;
+    border-top: 1px solid #ddd;
+    display: flex;
+    gap: 8px;
+    align-items: flex-end;
+}
+
+.input-area textarea {
+    flex: 1;
+    padding: 12px;
+    border: 1px solid #ddd;
+    border-radius: 6px;
+    font-family: inherit;
+    font-size: 14px;
+    resize: none;
+}
+
+.input-area textarea:focus {
+    outline: none;
+    border-color: #007bff;
+}
+
+.input-area textarea:disabled {
+    background-color: #f5f5f5;
+    cursor: not-allowed;
+}
+
+.btn-send {
+    padding: 12px 24px;
+    background-color: #007bff;
+    color: white;
+    border: none;
+    border-radius: 6px;
+    cursor: pointer;
+    font-size: 14px;
+    font-weight: 500;
+}
+
+.btn-send:hover:not(:disabled) {
+    background-color: #0056b3;
+}
+
+.btn-send:disabled {
+    background-color: #ccc;
+    cursor: not-allowed;
+}
+
+.btn-cancel {
+    padding: 12px 24px;
+    background-color: #dc3545;
+    color: white;
+    border: none;
+    border-radius: 6px;
+    cursor: pointer;
+    font-size: 14px;
+    font-weight: 500;
+}
+
+.btn-cancel:hover {
+    background-color: #c82333;
+}
+
+/* ============================================================================
+   Dialog
+   ============================================================================ */
+
+.dialog {
+    position: fixed;
+    top: 0;
+    left: 0;
+    right: 0;
+    bottom: 0;
+    background-color: rgba(0, 0, 0, 0.5);
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    z-index: 1000;
+}
+
+.dialog-content {
+    background-color: white;
+    padding: 24px;
+    border-radius: 8px;
+    box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
+    min-width: 400px;
+    max-width: 500px;
+}
+
+.dialog-content h2 {
+    font-size: 20px;
+    font-weight: 600;
+    margin-bottom: 20px;
+}
+
+.dialog-content form {
+    display: flex;
+    flex-direction: column;
+    gap: 16px;
+}
+
+.dialog-content label {
+    display: flex;
+    flex-direction: column;
+    gap: 6px;
+    font-size: 14px;
+    font-weight: 500;
+}
+
+.dialog-content input {
+    padding: 10px;
+    border: 1px solid #ddd;
+    border-radius: 4px;
+    font-size: 14px;
+}
+
+.dialog-content input:focus {
+    outline: none;
+    border-color: #007bff;
+}
+
+.dialog-buttons {
+    display: flex;
+    gap: 8px;
+    justify-content: flex-end;
+    margin-top: 8px;
+}
+
+.btn-primary {
+    padding: 10px 20px;
+    background-color: #007bff;
+    color: white;
+    border: none;
+    border-radius: 4px;
+    cursor: pointer;
+    font-size: 14px;
+    font-weight: 500;
+}
+
+.btn-primary:hover {
+    background-color: #0056b3;
+}
+
+.btn-secondary {
+    padding: 10px 20px;
+    background-color: #6c757d;
+    color: white;
+    border: none;
+    border-radius: 4px;
+    cursor: pointer;
+    font-size: 14px;
+    font-weight: 500;
+}
+
+.btn-secondary:hover {
+    background-color: #5a6268;
+}
+
+/* ============================================================================
+   Scrollbar Styling
+   ============================================================================ */
+
+.worker-list::-webkit-scrollbar,
+.conversation::-webkit-scrollbar {
+    width: 8px;
+}
+
+.worker-list::-webkit-scrollbar-track,
+.conversation::-webkit-scrollbar-track {
+    background: #f1f1f1;
+}
+
+.worker-list::-webkit-scrollbar-thumb,
+.conversation::-webkit-scrollbar-thumb {
+    background: #888;
+    border-radius: 4px;
+}
+
+.worker-list::-webkit-scrollbar-thumb:hover,
+.conversation::-webkit-scrollbar-thumb:hover {
+    background: #555;
+}