diff --git a/Cargo.lock b/Cargo.lock
index ff03f048..d6f08232 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2238,6 +2238,7 @@ dependencies = [
  "tauri-plugin-window-state",
  "ureq",
  "url",
+ "uuid",
  "windows-sys 0.61.2",
 ]
 
diff --git a/src-tauri/Cargo.toml b/src-tauri/Cargo.toml
index 24f74f07..4e06d4cc 100644
--- a/src-tauri/Cargo.toml
+++ b/src-tauri/Cargo.toml
@@ -20,6 +20,7 @@ tauri = { version = "2", features = ["protocol-asset", "macos-private-api"] }
 tauri-plugin-opener = "2"
 serde.workspace = true
 serde_json.workspace = true
+uuid = { version = "1", features = ["v4"] }
 base64 = "0.22"
 tauri-plugin-dialog = "2"
 rusqlite = { version = "0.40.2", features = ["bundled"], default-features = false }
diff --git a/src-tauri/src/control.rs b/src-tauri/src/control.rs
new file mode 100644
index 00000000..20542e53
--- /dev/null
+++ b/src-tauri/src/control.rs
@@ -0,0 +1,552 @@
+//! Authenticated loopback transport. App windows own execution; callers never
+//! receive arbitrary Tauri command access or direct database write access.
+use std::collections::HashMap;
+use std::io::{BufRead, BufReader, Read, Write};
+use std::net::{TcpListener, TcpStream};
+use std::path::{Component, Path};
+use std::process::Command;
+use std::sync::{mpsc, Arc, Mutex};
+use std::time::Duration;
+
+use serde::{Deserialize, Serialize};
+use serde_json::{json, Value};
+use tauri::{AppHandle, Emitter, Manager, State, WebviewWindow};
+
+#[derive(Clone)]
+struct Grant {
+    window: String,
+    session: String,
+    cwd: String,
+    token: String,
+}
+struct Pending {
+    window: String,
+    reply: mpsc::Sender<Value>,
+}
+struct ActiveTurn {
+    window: String,
+    cwd: String,
+}
+#[derive(Default)]
+struct Inner {
+    grants: HashMap<String, Grant>,
+    pending: HashMap<String, Pending>,
+    workers: HashMap<String, String>,
+    active: HashMap<String, ActiveTurn>,
+}
+impl Inner {
+    fn window_sessions(&self, label: &str) -> Vec<String> {
+        let leads: Vec<String> = self
+            .grants
+            .values()
+            .filter(|grant| grant.window == label)
+            .map(|grant| grant.session.clone())
+            .collect();
+        let mut ids = leads.clone();
+        ids.extend(
+            self.workers
+                .iter()
+                .filter(|(_, lead)| leads.contains(lead))
+                .map(|(id, _)| id.clone()),
+        );
+        ids.extend(
+            self.active
+                .iter()
+                .filter(|(_, turn)| turn.window == label)
+                .map(|(id, _)| id.clone()),
+        );
+        ids.sort();
+        ids.dedup();
+        ids
+    }
+    fn close_window(&mut self, label: &str) -> Vec<String> {
+        let ids = self.window_sessions(label);
+        self.grants.retain(|id, _| !ids.contains(id));
+        self.workers.retain(|id, _| !ids.contains(id));
+        self.active.retain(|id, _| !ids.contains(id));
+        self.pending.retain(|_, pending| {
+            if pending.window != label {
+                return true;
+            }
+            let _ = pending
+                .reply
+                .send(json!({"ok":false,"error":"MonoCode window closed"}));
+            false
+        });
+        ids
+    }
+}
+pub struct ControlHost {
+    endpoint: String,
+    inner: Arc<Mutex<Inner>>,
+}
+
+fn paths_overlap(a: &str, b: &str) -> bool {
+    a == b || a.starts_with(&format!("{b}/")) || b.starts_with(&format!("{a}/"))
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct Request {
+    token: String,
+    action: String,
+    input: Value,
+    request_id: String,
+}
+
+#[derive(Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+struct Event {
+    id: String,
+    session_id: String,
+    request_id: String,
+    action: String,
+    input: Value,
+}
+
+pub fn init(app: &AppHandle) -> Result<(), String> {
+    let listener = TcpListener::bind("127.0.0.1:0").map_err(|e| e.to_string())?;
+    let endpoint = listener
+        .local_addr()
+        .map_err(|e| e.to_string())?
+        .to_string();
+    let inner = Arc::new(Mutex::new(Inner::default()));
+    app.manage(ControlHost {
+        endpoint,
+        inner: inner.clone(),
+    });
+    let app = app.clone();
+    std::thread::spawn(move || {
+        // Limit concurrent readers, including unauthenticated sockets.
+        let (tx, rx) = mpsc::sync_channel::<TcpStream>(32);
+        let rx = Arc::new(Mutex::new(rx));
+        for _ in 0..8 {
+            let rx = rx.clone();
+            let app = app.clone();
+            let inner = inner.clone();
+            std::thread::spawn(move || loop {
+                let stream = match rx.lock() {
+                    Ok(rx) => rx.recv(),
+                    Err(_) => return,
+                };
+                let Ok(stream) = stream else { return };
+                serve(stream, &app, &inner);
+            });
+        }
+        for stream in listener.incoming().flatten() {
+            let _ = tx.try_send(stream);
+        }
+    });
+    Ok(())
+}
+
+fn serve(mut stream: TcpStream, app: &AppHandle, inner: &Arc<Mutex<Inner>>) {
+    let _ = stream.set_read_timeout(Some(Duration::from_secs(3)));
+    let _ = stream.set_write_timeout(Some(Duration::from_secs(3)));
+    let result = (|| -> Result<Value, String> {
+        let mut raw = String::new();
+        BufReader::new(&mut stream)
+            .take(262_145)
+            .read_line(&mut raw)
+            .map_err(|e| e.to_string())?;
+        if raw.len() > 262_144 {
+            return Err("Request exceeds 256 KiB".into());
+        }
+        let request: Request = serde_json::from_str(&raw).map_err(|_| "Invalid control request")?;
+        if !request.input.is_object()
+            || request.request_id.is_empty()
+            || request.request_id.len() > 128
+        {
+            return Err("Invalid input or request ID".into());
+        }
+        let id = uuid::Uuid::new_v4().to_string();
+        let (tx, rx) = mpsc::channel();
+        let grant = {
+            let mut host = inner.lock().map_err(|_| "Control service unavailable")?;
+            let grant = host
+                .grants
+                .values()
+                .find(|g| g.token == request.token)
+                .cloned()
+                .ok_or("Connection revoked or unauthorized")?;
+            if host.pending.len() >= 24 {
+                return Err("Too many pending control requests".into());
+            }
+            host.pending.insert(
+                id.clone(),
+                Pending {
+                    window: grant.window.clone(),
+                    reply: tx,
+                },
+            );
+            grant
+        };
+        let event = Event {
+            id: id.clone(),
+            session_id: grant.session,
+            request_id: request.request_id,
+            action: request.action,
+            input: request.input,
+        };
+        let delivered = app.emit_to(grant.window.as_str(), "monocode-control-request", event);
+        let result = if delivered.is_err() {
+            Err("MonoCode executor is unavailable".into())
+        } else {
+            rx.recv_timeout(Duration::from_secs(35))
+                .map_err(|_| "Control request timed out. Retry with the same request ID.".into())
+        };
+        if let Ok(mut host) = inner.lock() {
+            host.pending.remove(&id);
+        }
+        result
+    })();
+    let response = result.unwrap_or_else(|error| json!({"ok": false, "error": error}));
+    let _ = writeln!(stream, "{response}");
+}
+
+#[tauri::command]
+pub fn control_enable(
+    window: WebviewWindow,
+    host: State<'_, ControlHost>,
+    session_id: String,
+    cwd: String,
+) -> Result<String, String> {
+    let cwd = std::fs::canonicalize(crate::fs::expand_home(&cwd)).map_err(|e| e.to_string())?;
+    if !cwd.is_dir() {
+        return Err("Choose a project folder first".into());
+    }
+    let cwd = cwd.to_string_lossy().replace('\\', "/").to_lowercase();
+    let mut inner = host
+        .inner
+        .lock()
+        .map_err(|_| "Control service unavailable")?;
+    if inner
+        .active
+        .iter()
+        .any(|(id, turn)| id != &session_id && paths_overlap(&turn.cwd, &cwd))
+    {
+        return Err(
+            "Another session is running in this checkout. Stop it before enabling orchestration."
+                .into(),
+        );
+    }
+    if inner.grants.values().any(|g| {
+        paths_overlap(&g.cwd, &cwd) && (g.session != session_id || g.window != window.label())
+    }) {
+        return Err("This checkout already has an orchestrator in another session".into());
+    }
+    inner.grants.insert(
+        session_id.clone(),
+        Grant {
+            window: window.label().into(),
+            session: session_id,
+            cwd,
+            token: format!(
+                "{}{}",
+                uuid::Uuid::new_v4().simple(),
+                uuid::Uuid::new_v4().simple()
+            ),
+        },
+    );
+    let executable = std::env::current_exe().map_err(|e| e.to_string())?;
+    Ok(executable.to_string_lossy().into_owned())
+}
+
+#[tauri::command]
+pub fn control_disable(
+    window: WebviewWindow,
+    host: State<'_, ControlHost>,
+    session_id: String,
+) -> Result<(), String> {
+    let mut inner = host
+        .inner
+        .lock()
+        .map_err(|_| "Control service unavailable")?;
+    if inner
+        .grants
+        .get(&session_id)
+        .is_some_and(|g| g.window == window.label())
+    {
+        inner.grants.remove(&session_id);
+        inner.workers.retain(|_, parent| parent != &session_id);
+    }
+    Ok(())
+}
+
+#[tauri::command]
+pub fn control_attach_worker(
+    window: WebviewWindow,
+    host: State<'_, ControlHost>,
+    lead_id: String,
+    session_id: String,
+) -> Result<(), String> {
+    let mut inner = host
+        .inner
+        .lock()
+        .map_err(|_| "Control service unavailable")?;
+    if !inner
+        .grants
+        .get(&lead_id)
+        .is_some_and(|grant| grant.window == window.label())
+    {
+        return Err("Lead connection is inactive".into());
+    }
+    inner.workers.insert(session_id, lead_id);
+    Ok(())
+}
+
+#[tauri::command]
+pub fn control_authorize_turn(
+    window: WebviewWindow,
+    host: State<'_, ControlHost>,
+    session_id: String,
+    cwd: String,
+) -> Result<(), String> {
+    let cwd = std::fs::canonicalize(crate::fs::expand_home(&cwd))
+        .map_err(|e| e.to_string())?
+        .to_string_lossy()
+        .replace('\\', "/")
+        .to_lowercase();
+    let mut inner = host
+        .inner
+        .lock()
+        .map_err(|_| "Control service unavailable")?;
+    if let Some(lead) = inner
+        .grants
+        .values()
+        .find(|grant| paths_overlap(&grant.cwd, &cwd))
+    {
+        if lead.window != window.label()
+            || (lead.session != session_id && inner.workers.get(&session_id) != Some(&lead.session))
+        {
+            return Err("This checkout is controlled by an orchestrator. Stop that run before starting independent work.".into());
+        }
+    }
+    inner.active.insert(
+        session_id,
+        ActiveTurn {
+            window: window.label().to_string(),
+            cwd,
+        },
+    );
+    Ok(())
+}
+
+#[tauri::command]
+pub fn control_turn_finished(host: State<'_, ControlHost>, session_id: String) {
+    if let Ok(mut inner) = host.inner.lock() {
+        inner.active.remove(&session_id);
+    }
+}
+
+pub fn window_closed(app: &AppHandle, label: &str) {
+    let host = app.state::<ControlHost>();
+    let ids = {
+        let Ok(inner) = host.inner.lock() else { return };
+        inner.window_sessions(label)
+    };
+    for id in &ids {
+        let _ = crate::harness::harness_kill(app.state(), id.clone());
+    }
+    if let Ok(mut inner) = host.inner.lock() {
+        inner.close_window(label);
+    };
+}
+
+pub fn configure_child(app: &AppHandle, session_id: &str, cmd: &mut Command) {
+    cmd.env_remove("MONOCODE_CONTROL_ENDPOINT")
+        .env_remove("MONOCODE_CONTROL_TOKEN");
+    let Some(host) = app.try_state::<ControlHost>() else {
+        return;
+    };
+    if let Ok(inner) = host.inner.lock() {
+        if let Some(grant) = inner.grants.get(session_id) {
+            cmd.env("MONOCODE_CONTROL_ENDPOINT", &host.endpoint)
+                .env("MONOCODE_CONTROL_TOKEN", &grant.token);
+        }
+    };
+}
+
+#[tauri::command]
+pub fn control_reply(
+    window: WebviewWindow,
+    host: State<'_, ControlHost>,
+    id: String,
+    response: Value,
+) -> Result<(), String> {
+    let mut inner = host
+        .inner
+        .lock()
+        .map_err(|_| "Control service unavailable")?;
+    if inner
+        .pending
+        .get(&id)
+        .is_some_and(|p| p.window == window.label())
+    {
+        if let Some(pending) = inner.pending.remove(&id) {
+            let _ = pending.reply.send(response);
+        }
+    }
+    Ok(())
+}
+
+#[tauri::command]
+pub fn control_save(
+    store: State<'_, crate::session_store::SessionStore>,
+    lead_id: String,
+    state: String,
+) -> Result<(), String> {
+    if state.len() > 8_000_000 {
+        return Err("Orchestration history is too large".into());
+    }
+    let run: Value = serde_json::from_str(&state).map_err(|_| "Invalid run state")?;
+    let conn = store.lock_conn()?;
+    crate::session_store::save_orchestration(&conn, &lead_id, &run).map_err(|e| e.to_string())?;
+    Ok(())
+}
+
+#[tauri::command]
+pub fn control_load(
+    store: State<'_, crate::session_store::SessionStore>,
+    lead_id: String,
+) -> Result<Option<String>, String> {
+    use rusqlite::OptionalExtension;
+    store
+        .lock_conn()?
+        .query_row(
+            "SELECT state FROM orchestration_runs WHERE lead_id=?1",
+            [lead_id],
+            |r| r.get(0),
+        )
+        .optional()
+        .map_err(|e| e.to_string())
+}
+
+fn resolve_scope(root: &Path, value: &str) -> Result<String, String> {
+    let path = Path::new(value);
+    if value.is_empty()
+        || path.is_absolute()
+        || path
+            .components()
+            .any(|c| matches!(c, Component::ParentDir | Component::Prefix(_)))
+    {
+        return Err("Write scopes must be project-relative paths without '..'".into());
+    }
+    let root = std::fs::canonicalize(root).map_err(|e| e.to_string())?;
+    let mut existing = root.join(path);
+    let mut missing = Vec::new();
+    while !existing.exists() {
+        missing.push(existing.file_name().ok_or("Invalid scope")?.to_os_string());
+        if !existing.pop() {
+            return Err("Invalid scope".into());
+        }
+    }
+    existing = std::fs::canonicalize(existing).map_err(|e| e.to_string())?;
+    if !existing.starts_with(&root) {
+        return Err("Write scope points outside the project".into());
+    }
+    for part in missing.into_iter().rev() {
+        existing.push(part);
+    }
+    Ok(existing.to_string_lossy().replace('\\', "/").to_lowercase())
+}
+
+#[tauri::command]
+pub fn control_scopes(cwd: String, files: Vec<String>) -> Result<Vec<String>, String> {
+    if files.len() > 64 {
+        return Err("At most 64 write scopes per task".into());
+    }
+    files
+        .iter()
+        .map(|file| resolve_scope(&crate::fs::expand_home(&cwd), file))
+        .collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn closing_a_window_releases_ordinary_turns_and_owned_orchestration() {
+        let mut inner = Inner::default();
+        for (id, window) in [
+            ("ordinary", "closing"),
+            ("lead", "closing"),
+            ("other", "open"),
+        ] {
+            inner.active.insert(
+                id.into(),
+                ActiveTurn {
+                    window: window.into(),
+                    cwd: format!("/{id}"),
+                },
+            );
+        }
+        for (id, window) in [("lead", "closing"), ("other", "open")] {
+            inner.grants.insert(
+                id.into(),
+                Grant {
+                    window: window.into(),
+                    session: id.into(),
+                    cwd: format!("/{id}"),
+                    token: id.into(),
+                },
+            );
+        }
+        inner.workers.insert("worker".into(), "lead".into());
+        inner.workers.insert("other-worker".into(), "other".into());
+        let (reply, response) = mpsc::channel();
+        inner.pending.insert(
+            "pending".into(),
+            Pending {
+                window: "closing".into(),
+                reply,
+            },
+        );
+        let (reply, other_response) = mpsc::channel();
+        inner.pending.insert(
+            "other-pending".into(),
+            Pending {
+                window: "open".into(),
+                reply,
+            },
+        );
+
+        assert_eq!(
+            inner.close_window("closing"),
+            ["lead", "ordinary", "worker"]
+        );
+        assert_eq!(inner.active.len(), 1);
+        assert_eq!(inner.active["other"].window, "open");
+        assert_eq!(inner.grants.len(), 1);
+        assert!(inner.grants.contains_key("other"));
+        assert_eq!(inner.workers.len(), 1);
+        assert_eq!(inner.workers["other-worker"], "other");
+        assert_eq!(response.try_recv().unwrap()["ok"], false);
+        assert!(other_response.try_recv().is_err());
+        assert!(inner.pending.contains_key("other-pending"));
+        assert!(inner.close_window("closing").is_empty());
+    }
+
+    #[test]
+    fn scopes_reject_escape_and_resolve_new_files() {
+        let root = std::env::temp_dir().join(uuid::Uuid::new_v4().to_string());
+        std::fs::create_dir_all(&root).unwrap();
+        assert!(resolve_scope(&root, "../escape").is_err());
+        assert!(resolve_scope(&root, "/absolute").is_err());
+        assert!(resolve_scope(&root, "src/new.ts")
+            .unwrap()
+            .ends_with("/src/new.ts"));
+        #[cfg(unix)]
+        {
+            std::os::unix::fs::symlink(std::env::temp_dir(), root.join("outside")).unwrap();
+            assert!(resolve_scope(&root, "outside/file").is_err());
+        }
+        std::fs::remove_dir_all(root).unwrap();
+    }
+    #[test]
+    fn checkout_reservations_include_nested_folders() {
+        assert!(paths_overlap("/repo", "/repo/src"));
+        assert!(paths_overlap("/repo/src", "/repo"));
+        assert!(!paths_overlap("/repo", "/repo2"));
+    }
+}
diff --git a/src-tauri/src/control_cli.rs b/src-tauri/src/control_cli.rs
new file mode 100644
index 00000000..3856f5d4
--- /dev/null
+++ b/src-tauri/src/control_cli.rs
@@ -0,0 +1,373 @@
+//! The desktop executable also provides a small, JSON-only control client.
+use std::io::{BufRead, BufReader, Read, Write};
+use std::net::{SocketAddr, TcpStream};
+use std::time::Duration;
+
+use serde_json::{json, Value};
+
+const USAGE: &str = r#"MonoCode local control — supervise this orchestration run from the lead agent.
+
+Usage: {exe} control ACTION [--json JSON | --input FILE|-] [--request-id ID]
+
+Actions, with the JSON object each one takes:
+  list      {}
+            The run, every task with its status and latest result, and the
+            harness/model IDs you may assign.
+  delegate  {"title":"Short title","harness":"<id from list>",
+             "model":"<id from list>","prompt":"Self-contained instructions",
+             "files":["src/feature"],"dependsOn":["<taskId>"]}
+            Queue a worker and return its taskId. "model" is optional and
+            defaults to the first model list allows for that harness.
+            "files" is the write scope: project-relative paths, where a
+            directory covers its descendants and ["."] reserves the whole
+            checkout. "dependsOn" holds taskIds that must be reviewed first.
+  get       {"taskId":"..."}
+            One task, including its latest result.
+  wait      {"timeoutSeconds":20}
+            Block until a task changes state, or until the timeout (0-25).
+            Returns at once when nothing is running or queued.
+  respond   {"taskId":"...","requestId":7,"decision":"allow"|"deny"}
+            Answer an approval an agent is blocked on. Agents never prompt the
+            user; list, get and wait report the prompt as that task's
+            "needsInput", and it stays stopped until you decide.
+  answer    {"taskId":"...","requestId":9,"answers":{"<questionId>":["<optionId>"]}}
+            Answer a question an agent asked, or pass "skip":true instead of
+            "answers". The question and its options come from needsInput.
+  steer     {"taskId":"...","text":"..."}
+            Redirect an agent that is still running, without discarding the
+            work it has already done. Use this the moment you see it going
+            the wrong way; message only lands once it has stopped.
+  message   {"taskId":"...","text":"..."}
+            Send a completed or failed worker another turn; it keeps its
+            session, scope and history.
+  cancel    {"taskId":"..."}
+            Cancel a task, whether it is running or still queued.
+  review    {"taskId":"..."}
+            Accept a completed task's result.
+  finish    {}
+            End the run, once every task is accepted or cancelled.
+
+Usual loop: list -> delegate ... -> wait or get -> steer an agent that drifts,
+unblock one with respond or answer -> inspect the changes yourself -> message
+for corrections -> review each task -> finish.
+
+Output is one JSON line: {"ok":true,"result":...} or {"ok":false,"error":"..."}.
+The exit code is 0 only when "ok" is true.
+
+Input must be a JSON object; unknown fields are rejected rather than ignored.
+--json takes it inline, --input FILE reads a file, --input - reads stdin.
+
+Every call carries a request ID, and the run applies each ID at most once. A
+failed response reports the ID it used whenever the outcome is unknown — a
+timeout, say. Retry that exact call with --request-id ID; retrying a delegate
+under a fresh ID instead would queue a second worker.
+
+Tasks run inside the MonoCode app, not in this process. Exiting this CLI, or a
+failure here, never cancels a task that was already accepted.
+
+MonoCode sets MONOCODE_CONTROL_ENDPOINT and MONOCODE_CONTROL_TOKEN for the lead
+agent's process only. They are already in your environment; never print them.
+"#;
+
+const ACTIONS: [&str; 11] = [
+    "list", "delegate", "get", "steer", "message", "cancel", "wait", "review", "finish", "respond",
+    "answer",
+];
+
+/// Quote for the shell the lead agent actually runs commands in, and only when
+/// the path needs it. The path is absolute, so a leading slash means a POSIX
+/// shell — where a backslash escapes rather than separates, and so is never
+/// safe bare.
+fn quoted(value: &str) -> String {
+    if !value.starts_with('/') {
+        return if value.contains([' ', '\t', '"']) {
+            format!("\"{}\"", value.replace('"', ""))
+        } else {
+            value.into()
+        };
+    }
+    if value
+        .chars()
+        .all(|c| c.is_ascii_alphanumeric() || "._/-:".contains(c))
+    {
+        value.into()
+    } else {
+        format!("'{}'", value.replace('\'', r"'\''"))
+    }
+}
+
+pub fn help() -> String {
+    let exe = std::env::current_exe()
+        .map(|path| quoted(&path.to_string_lossy()))
+        .unwrap_or_else(|_| "monocode".into());
+    USAGE.replace("{exe}", &exe)
+}
+
+enum Parsed {
+    Help,
+    Call(String, Value, String),
+}
+
+pub fn run(args: Vec<String>) -> i32 {
+    let parsed = match parse_args(&args) {
+        Ok(parsed) => parsed,
+        Err(error) => {
+            println!("{}", json!({"ok": false, "error": error}));
+            return 1;
+        }
+    };
+    let (action, input, request_id) = match parsed {
+        Parsed::Help => {
+            println!("{}", help());
+            return 0;
+        }
+        Parsed::Call(action, input, request_id) => (action, input, request_id),
+    };
+    match send(&action, &input, &request_id) {
+        Ok(mut value) => {
+            if value.get("ok").and_then(Value::as_bool) == Some(true) {
+                println!("{value}");
+                return 0;
+            }
+            // MonoCode may have timed out waiting on its own executor, so a
+            // failure here is not proof the call was rejected either.
+            if let Some(object) = value.as_object_mut() {
+                object
+                    .entry("requestId")
+                    .or_insert_with(|| json!(request_id));
+                object
+                    .entry("retryWith")
+                    .or_insert_with(|| json!(format!("--request-id {request_id}")));
+            }
+            println!("{value}");
+            1
+        }
+        Err(Failure { error, sent }) => {
+            // The call may have reached the run even though its answer was
+            // lost. Hand back the request ID so a retry cannot duplicate it.
+            let mut response = json!({"ok": false, "error": error});
+            if sent {
+                response["requestId"] = json!(request_id);
+                response["retryWith"] = json!(format!("--request-id {request_id}"));
+            }
+            println!("{response}");
+            1
+        }
+    }
+}
+
+struct Failure {
+    error: String,
+    /// The request was already on the wire, so the run may have applied it.
+    sent: bool,
+}
+fn unsent(error: impl Into<String>) -> Failure {
+    Failure {
+        error: error.into(),
+        sent: false,
+    }
+}
+fn sent(error: impl Into<String>) -> Failure {
+    Failure {
+        error: error.into(),
+        sent: true,
+    }
+}
+
+fn send(action: &str, input: &Value, request_id: &str) -> Result<Value, Failure> {
+    let endpoint = std::env::var("MONOCODE_CONTROL_ENDPOINT").map_err(|_| {
+        unsent("No MonoCode connection. Confirm the Orchestrator proposal in MonoCode first.")
+    })?;
+    let token = std::env::var("MONOCODE_CONTROL_TOKEN")
+        .map_err(|_| unsent("No MonoCode session credential. Start the lead from MonoCode."))?;
+    let address: SocketAddr = endpoint
+        .parse()
+        .map_err(|_| unsent("Invalid MonoCode endpoint"))?;
+    if !address.ip().is_loopback() {
+        return Err(unsent("MonoCode control only connects to localhost"));
+    }
+    let mut stream = TcpStream::connect_timeout(&address, Duration::from_secs(3))
+        .map_err(|_| unsent("MonoCode is not running or this connection has expired."))?;
+    stream
+        .set_read_timeout(Some(Duration::from_secs(40)))
+        .map_err(|e| unsent(e.to_string()))?;
+    stream
+        .set_write_timeout(Some(Duration::from_secs(5)))
+        .map_err(|e| unsent(e.to_string()))?;
+    writeln!(
+        stream,
+        "{}",
+        json!({"token":token,"action":action,"input":input,"requestId":request_id})
+    )
+    .map_err(|e| sent(e.to_string()))?;
+    let mut line = String::new();
+    BufReader::new(stream)
+        .take(2_000_001)
+        .read_line(&mut line)
+        .map_err(|e| sent(format!("No reply from MonoCode: {e}")))?;
+    if line.len() > 2_000_000 {
+        return Err(sent("MonoCode response is too large"));
+    }
+    serde_json::from_str(&line).map_err(|_| sent("MonoCode returned an invalid response"))
+}
+
+fn read_capped(mut source: impl Read) -> Result<String, String> {
+    let mut raw = String::new();
+    source
+        .by_ref()
+        .take(262_145)
+        .read_to_string(&mut raw)
+        .map_err(|e| e.to_string())?;
+    if raw.len() > 262_144 {
+        return Err("Input exceeds 256 KiB".into());
+    }
+    Ok(raw)
+}
+
+fn parse_args(args: &[String]) -> Result<Parsed, String> {
+    let is_help = |value: &str| matches!(value, "help" | "--help" | "-h");
+    let Some(action) = args.first() else {
+        return Ok(Parsed::Help);
+    };
+    if is_help(action) {
+        return Ok(Parsed::Help);
+    }
+    let action = action.clone();
+    if !ACTIONS.contains(&action.as_str()) {
+        return Err(format!(
+            "Unknown action: {action}. Use one of: {}. Run control --help.",
+            ACTIONS.join(", ")
+        ));
+    }
+    let mut input = None;
+    let mut request_id = uuid::Uuid::new_v4().to_string();
+    let mut index = 1;
+    while index < args.len() {
+        let flag = &args[index];
+        // `control delegate --help` should explain the command, not fail.
+        if is_help(flag) {
+            return Ok(Parsed::Help);
+        }
+        if !flag.starts_with("--") {
+            return Err(format!(
+                "Unexpected argument: {flag}. Pass the JSON object as --json '<JSON>'."
+            ));
+        }
+        let value = args.get(index + 1).ok_or_else(|| {
+            format!("Missing value for {flag}. Run control --help for the argument list.")
+        })?;
+        match flag.as_str() {
+            "--request-id" => request_id = value.clone(),
+            "--json" | "--input" => {
+                if input.is_some() {
+                    return Err("Supply only one input".into());
+                }
+                let raw = if flag == "--json" {
+                    if value.len() > 262_144 {
+                        return Err("Input exceeds 256 KiB".into());
+                    }
+                    value.clone()
+                } else if value == "-" {
+                    read_capped(std::io::stdin())?
+                } else {
+                    read_capped(std::fs::File::open(value).map_err(|e| e.to_string())?)?
+                };
+                let parsed: Value = serde_json::from_str(&raw)
+                    .map_err(|e| format!("Invalid JSON: {e}. Pass one JSON object, e.g. --json '{{\"taskId\":\"...\"}}'."))?;
+                if !parsed.is_object() {
+                    return Err("Input must be a JSON object".into());
+                }
+                input = Some(parsed);
+            }
+            _ => {
+                return Err(format!(
+                    "Unknown option: {flag}. Supported: --json, --input, --request-id."
+                ))
+            }
+        }
+        index += 2;
+    }
+    if request_id.is_empty() || request_id.len() > 128 {
+        return Err("Invalid request ID".into());
+    }
+    Ok(Parsed::Call(
+        action,
+        input.unwrap_or_else(|| json!({})),
+        request_id,
+    ))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    fn args(values: &[&str]) -> Vec<String> {
+        values.iter().map(|s| s.to_string()).collect()
+    }
+    fn call(values: &[&str]) -> Result<(String, Value, String), String> {
+        match parse_args(&args(values))? {
+            Parsed::Call(action, input, id) => Ok((action, input, id)),
+            Parsed::Help => Err("help".into()),
+        }
+    }
+    #[test]
+    fn validates_inputs_without_invoking_a_shell() {
+        let (_, input, id) = call(&[
+            "delegate",
+            "--json",
+            r#"{"prompt":"$(touch nope) `hello`\nnext"}"#,
+            "--request-id",
+            "retry-1",
+        ])
+        .unwrap();
+        assert_eq!(id, "retry-1");
+        assert_eq!(input["prompt"], "$(touch nope) `hello`\nnext");
+        assert!(call(&["delegate", "--json", "[]"]).is_err());
+        assert!(call(&["delegate", "--json", "{}", "--json", "{}"]).is_err());
+        assert!(call(&["unknown"]).is_err());
+    }
+    #[test]
+    fn explains_help_and_malformed_invocations() {
+        assert!(matches!(parse_args(&args(&[])), Ok(Parsed::Help)));
+        assert!(matches!(parse_args(&args(&["--help"])), Ok(Parsed::Help)));
+        // Agents commonly probe a subcommand for its own usage text.
+        assert!(matches!(
+            parse_args(&args(&["delegate", "--help"])),
+            Ok(Parsed::Help)
+        ));
+        assert!(call(&["get", r#"{"taskId":"x"}"#])
+            .unwrap_err()
+            .contains("--json"));
+        assert!(call(&["get", "--json"]).unwrap_err().contains("--help"));
+        assert!(call(&["get", "--taskId", "x"])
+            .unwrap_err()
+            .contains("Unknown option"));
+        assert!(call(&["get", "--json", "{taskId}"])
+            .unwrap_err()
+            .contains("Invalid JSON"));
+    }
+    #[test]
+    fn help_names_every_action_and_the_real_executable() {
+        let text = help();
+        for action in ACTIONS {
+            assert!(text.contains(action), "help omits {action}");
+        }
+        assert!(!text.contains("{exe}"));
+        assert!(text.contains("--request-id"));
+    }
+    #[test]
+    fn quotes_the_control_path_only_when_the_shell_needs_it() {
+        assert_eq!(
+            quoted("/Applications/MonoCode.app/Contents/MacOS/monocode"),
+            "/Applications/MonoCode.app/Contents/MacOS/monocode"
+        );
+        assert_eq!(quoted("/Users/a b/MonoCode"), "'/Users/a b/MonoCode'");
+        assert_eq!(quoted("C:\\Tools\\monocode.exe"), "C:\\Tools\\monocode.exe");
+        assert_eq!(
+            quoted("C:\\Program Files\\MonoCode\\monocode.exe"),
+            "\"C:\\Program Files\\MonoCode\\monocode.exe\""
+        );
+        // A backslash escapes in a POSIX shell, so bare would rewrite the path.
+        assert_eq!(quoted("/Users/a\\b/MonoCode"), "'/Users/a\\b/MonoCode'");
+        assert_eq!(quoted("/Users/it's/MonoCode"), r"'/Users/it'\''s/MonoCode'");
+    }
+}
diff --git a/src-tauri/src/harness.rs b/src-tauri/src/harness.rs
index b61fa28e..8c345fc9 100644
--- a/src-tauri/src/harness.rs
+++ b/src-tauri/src/harness.rs
@@ -348,6 +348,8 @@ pub fn harness_spawn(
         .stderr(Stdio::piped());
     prepare_child(&mut cmd, &command);
 
+    crate::control::configure_child(&app, &session_id, &mut cmd);
+
     let mut child =
         spawn_managed(&mut cmd).map_err(|e| format!("Failed to start {command}: {e}"))?;
     let pid = child.id();
diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs
index 09b39dcf..07181a3c 100644
--- a/src-tauri/src/lib.rs
+++ b/src-tauri/src/lib.rs
@@ -2,6 +2,8 @@ use tauri::Manager;
 
 mod chat_background;
 mod checkpoint;
+mod control;
+pub mod control_cli;
 mod cursor_store;
 mod fs;
 mod gitlab;
@@ -197,6 +199,7 @@ pub fn run() {
         .setup(|app| {
             harness::reap_orphaned_harness_processes();
             session_store::init(app.handle())?;
+            control::init(app.handle())?;
             reminders::init(app.handle());
             checkpoint::init(app.handle())?;
             menu::install(app.handle())?;
@@ -220,6 +223,15 @@ pub fn run() {
             menu::dispatch(app, event.id().as_ref());
         })
         .invoke_handler(tauri::generate_handler![
+            control::control_enable,
+            control::control_disable,
+            control::control_reply,
+            control::control_save,
+            control::control_load,
+            control::control_scopes,
+            control::control_attach_worker,
+            control::control_authorize_turn,
+            control::control_turn_finished,
             default_cwd,
             home_dir,
             notifications::notification_permission,
@@ -403,6 +415,7 @@ pub fn run() {
             ..
         } => {
             let other_window = handle.webview_windows().keys().any(|name| name != &label);
+            control::window_closed(handle, &label);
             if !other_window {
                 reap_harness_children(handle);
             }
diff --git a/src-tauri/src/main.rs b/src-tauri/src/main.rs
index 3b2b9e17..8af4da08 100644
--- a/src-tauri/src/main.rs
+++ b/src-tauri/src/main.rs
@@ -1,6 +1,11 @@
 #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
 
 fn main() {
+    if std::env::args().nth(1).as_deref() == Some("control") {
+        std::process::exit(monocode_lib::control_cli::run(
+            std::env::args().skip(2).collect(),
+        ));
+    }
     #[cfg(all(debug_assertions, target_os = "macos"))]
     monocode_lib::ensure_macos_dev_bundle();
     monocode_lib::run()
diff --git a/src-tauri/src/session_store.rs b/src-tauri/src/session_store.rs
index 2090ad55..82e75647 100644
--- a/src-tauri/src/session_store.rs
+++ b/src-tauri/src/session_store.rs
@@ -4,7 +4,7 @@ use std::time::{SystemTime, UNIX_EPOCH};
 
 use rusqlite::{params, Connection, OptionalExtension};
 use serde::{Deserialize, Serialize};
-use serde_json::Value;
+use serde_json::{json, Value};
 use tauri::{AppHandle, Emitter, Manager, State};
 
 const MIGRATION_V1: &str = r#"
@@ -99,6 +99,10 @@ pub struct SessionUpsert {
 #[serde(rename_all = "camelCase")]
 pub struct SessionSummary {
     pub id: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub orchestration_lead_id: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub orchestration: Option<Value>,
     pub cwd: String,
     pub harness: String,
     pub model: String,
@@ -126,6 +130,8 @@ pub struct SessionSummary {
 #[serde(rename_all = "camelCase")]
 pub struct SessionRecord {
     pub id: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub orchestration_lead_id: Option<String>,
     pub cwd: String,
     pub harness: String,
     pub model: String,
@@ -603,9 +609,128 @@ fn migrate(conn: &Connection) -> rusqlite::Result<()> {
     )?;
     crate::notes::ensure_notes_table(conn)?;
     crate::reminders::ensure_table(conn)?;
+    ensure_orchestration_history(conn)?;
     Ok(())
 }
 
+fn ensure_orchestration_history(conn: &Connection) -> rusqlite::Result<()> {
+    let indexed: bool = conn.query_row(
+        "SELECT EXISTS(SELECT 1 FROM sqlite_master WHERE name = 'orchestration_sidebar')",
+        [],
+        |row| row.get(0),
+    )?;
+    let tx = conn.unchecked_transaction()?;
+    tx.execute_batch(
+        "CREATE TABLE IF NOT EXISTS orchestration_runs (lead_id TEXT PRIMARY KEY, state TEXT NOT NULL);
+         CREATE TABLE IF NOT EXISTS orchestration_sidebar (lead_id TEXT PRIMARY KEY, summary TEXT NOT NULL);
+         CREATE TABLE IF NOT EXISTS orchestration_workers (session_id TEXT PRIMARY KEY, lead_id TEXT NOT NULL);",
+    )?;
+    if !indexed {
+        // One-time compatibility pass for the preview that listed workers as
+        // separate chats. Normal sidebar reads never scan transcripts/run blobs.
+        let runs = tx
+            .prepare("SELECT lead_id, state FROM orchestration_runs")?
+            .query_map([], |row| {
+                Ok((row.get::<_, String>(0)?, row.get::<_, String>(1)?))
+            })?
+            .collect::<rusqlite::Result<Vec<_>>>()?;
+        for (lead, state) in runs {
+            if let Ok(run) = serde_json::from_str::<Value>(&state) {
+                index_orchestration(&tx, &lead, &run)?;
+            }
+        }
+        let workers = tx.prepare("SELECT id, blocks_json FROM sessions WHERE blocks_json LIKE '%orchestrationLeadId%'")?
+            .query_map([], |row| Ok((row.get::<_, String>(0)?, row.get::<_, String>(1)?)))?
+            .collect::<rusqlite::Result<Vec<_>>>()?;
+        for (id, blocks) in workers {
+            if let Ok(blocks) = serde_json::from_str::<Value>(&blocks) {
+                remember_worker_from_blocks(&tx, &id, &blocks)?;
+            }
+        }
+    }
+    tx.commit()
+}
+
+fn remember_worker(conn: &Connection, id: &str, lead: &str) -> rusqlite::Result<()> {
+    if id != lead && validate_id(id, "Worker").is_ok() && validate_id(lead, "Lead").is_ok() {
+        // Keep earlier workers indexed when a lead starts a subsequent run.
+        conn.execute(
+            "INSERT OR IGNORE INTO orchestration_workers(session_id, lead_id) VALUES (?1, ?2)",
+            params![id, lead],
+        )?;
+    }
+    Ok(())
+}
+
+fn remember_worker_from_blocks(
+    conn: &Connection,
+    id: &str,
+    blocks: &Value,
+) -> rusqlite::Result<()> {
+    if let Some(blocks) = blocks.as_array() {
+        for block in blocks {
+            if block["role"] == "user" {
+                if let Some(lead) = block["orchestrationLeadId"].as_str() {
+                    remember_worker(conn, id, lead)?;
+                    break;
+                }
+            }
+        }
+    }
+    Ok(())
+}
+
+fn index_orchestration(conn: &Connection, lead: &str, run: &Value) -> rusqlite::Result<()> {
+    let Some(tasks) = run["tasks"].as_array() else {
+        return Ok(());
+    };
+    let mut summaries = Vec::new();
+    for task in tasks {
+        let Some(id) = task["sessionId"].as_str() else {
+            continue;
+        };
+        remember_worker(conn, id, lead)?;
+        summaries.push(serde_json::json!({
+            "sessionId": id, "title": task["title"], "harness": task["harness"],
+            "model": task["model"], "status": task["status"],
+        }));
+    }
+    let summary = serde_json::json!({ "status": run["status"], "tasks": summaries });
+    conn.execute("INSERT INTO orchestration_sidebar(lead_id, summary) VALUES (?1, ?2) ON CONFLICT(lead_id) DO UPDATE SET summary = excluded.summary", params![lead, summary.to_string()])?;
+    Ok(())
+}
+
+pub(crate) fn save_orchestration(
+    conn: &Connection,
+    lead: &str,
+    run: &Value,
+) -> rusqlite::Result<()> {
+    let tx = conn.unchecked_transaction()?;
+    tx.execute("INSERT INTO orchestration_runs(lead_id, state) VALUES (?1, ?2) ON CONFLICT(lead_id) DO UPDATE SET state = excluded.state", params![lead, run.to_string()])?;
+    index_orchestration(&tx, lead, run)?;
+    tx.commit()
+}
+
+fn worker_parent(conn: &Connection, id: &str) -> rusqlite::Result<Option<String>> {
+    conn.query_row(
+        "SELECT lead_id FROM orchestration_workers WHERE session_id = ?1",
+        [id],
+        |row| row.get(0),
+    )
+    .optional()
+}
+
+fn orchestration_summary(conn: &Connection, id: &str) -> rusqlite::Result<Option<Value>> {
+    Ok(optional_json(
+        conn.query_row(
+            "SELECT summary FROM orchestration_sidebar WHERE lead_id = ?1",
+            [id],
+            |row| row.get(0),
+        )
+        .optional()?,
+    ))
+}
+
 fn upsert_session(conn: &Connection, session: &SessionUpsert) -> rusqlite::Result<SessionSummary> {
     let now = now_millis();
     let model_settings = serde_json::to_string(&session.model_settings)
@@ -708,8 +833,11 @@ fn upsert_session(conn: &Connection, session: &SessionUpsert) -> rusqlite::Resul
         ],
     )?;
 
+    remember_worker_from_blocks(conn, &session.id, &session.blocks)?;
     Ok(SessionSummary {
         id: session.id.clone(),
+        orchestration_lead_id: worker_parent(conn, &session.id)?,
+        orchestration: orchestration_summary(conn, &session.id)?,
         cwd: session.cwd.clone(),
         harness: session.harness.clone(),
         model: session.model.clone(),
@@ -979,11 +1107,13 @@ fn list_by_project(conn: &Connection, cwd: &str) -> rusqlite::Result<Vec<Session
     let mut statement = conn.prepare(
         "SELECT id, cwd, harness, model, runtime_mode, title, provider_session_id,
                 created_at, updated_at, branch, archived, pinned,
-                linked_work_item_json
+                linked_work_item_json,
+                (SELECT summary FROM orchestration_sidebar WHERE lead_id = sessions.id)
          FROM sessions
          WHERE cwd = ?1
            AND has_user_message = 1
            AND id NOT IN (SELECT id FROM sessions WHERE inbox_ask IS NOT NULL)
+           AND id NOT IN (SELECT session_id FROM orchestration_workers)
          ORDER BY updated_at DESC, id ASC",
     )?;
     let rows = statement.query_map(params![cwd], |row| {
@@ -993,6 +1123,8 @@ fn list_by_project(conn: &Connection, cwd: &str) -> rusqlite::Result<Vec<Session
         let linked_work_item = optional_json(row.get(12)?);
         Ok(SessionSummary {
             id: row.get(0)?,
+            orchestration_lead_id: None,
+            orchestration: optional_json(row.get(13)?),
             cwd: row.get(1)?,
             harness: row.get(2)?,
             model: row.get(3)?,
@@ -1017,11 +1149,13 @@ fn list_linked(conn: &Connection) -> rusqlite::Result<Vec<SessionSummary>> {
     let mut statement = conn.prepare(
         "SELECT id, cwd, harness, model, runtime_mode, title, provider_session_id,
                 created_at, updated_at, branch, archived, pinned,
-                linked_work_item_json
+                linked_work_item_json,
+                (SELECT summary FROM orchestration_sidebar WHERE lead_id = sessions.id)
          FROM sessions
          WHERE has_user_message = 1
            AND linked_work_item_json IS NOT NULL
            AND id NOT IN (SELECT id FROM sessions WHERE inbox_ask IS NOT NULL)
+           AND id NOT IN (SELECT session_id FROM orchestration_workers)
          ORDER BY updated_at DESC, id ASC",
     )?;
     let rows = statement.query_map([], |row| {
@@ -1029,6 +1163,8 @@ fn list_linked(conn: &Connection) -> rusqlite::Result<Vec<SessionSummary>> {
         let pinned: i64 = row.get(11)?;
         Ok(SessionSummary {
             id: row.get(0)?,
+            orchestration_lead_id: None,
+            orchestration: optional_json(row.get(13)?),
             cwd: row.get(1)?,
             harness: row.get(2)?,
             model: row.get(3)?,
@@ -1075,8 +1211,114 @@ fn optional_json(raw: Option<String>) -> Option<Value> {
 }
 
 fn delete_session(conn: &Connection, session_id: &str) -> rusqlite::Result<()> {
-    conn.execute("DELETE FROM sessions WHERE id = ?1", params![session_id])?;
-    Ok(())
+    let tx = conn.unchecked_transaction()?;
+    let parent = worker_parent(&tx, session_id)?;
+    // Ownership is also carried in transcripts for older clients. Release
+    // that metadata along with the index so reopening a worker stays detached.
+    let workers = tx.prepare("SELECT id, blocks_json FROM sessions WHERE id IN (SELECT session_id FROM orchestration_workers WHERE lead_id = ?1)")?
+        .query_map([session_id], |row| Ok((row.get::<_, String>(0)?, row.get::<_, String>(1)?)))?
+        .collect::<rusqlite::Result<Vec<_>>>()?;
+    for (id, raw) in workers {
+        let mut blocks: Value = serde_json::from_str(&raw).map_err(|e| {
+            rusqlite::Error::FromSqlConversionFailure(0, rusqlite::types::Type::Text, Box::new(e))
+        })?;
+        if let Some(blocks) = blocks.as_array_mut() {
+            for block in blocks {
+                if block["orchestrationLeadId"] == session_id {
+                    if let Some(block) = block.as_object_mut() {
+                        block.remove("orchestrationLeadId");
+                    }
+                }
+            }
+        }
+        tx.execute(
+            "UPDATE sessions SET blocks_json = ?1 WHERE id = ?2",
+            params![blocks.to_string(), id],
+        )?;
+    }
+    tx.execute(
+        "DELETE FROM orchestration_runs WHERE lead_id = ?1",
+        [session_id],
+    )?;
+    tx.execute(
+        "DELETE FROM orchestration_sidebar WHERE lead_id = ?1",
+        [session_id],
+    )?;
+    if let Some(parent) = parent.filter(|id| id != session_id) {
+        let raw: Option<String> = tx
+            .query_row(
+                "SELECT state FROM orchestration_runs WHERE lead_id = ?1",
+                [&parent],
+                |row| row.get(0),
+            )
+            .optional()?;
+        if let Some(raw) = raw {
+            let mut run: Value = serde_json::from_str(&raw).map_err(|e| {
+                rusqlite::Error::FromSqlConversionFailure(
+                    0,
+                    rusqlite::types::Type::Text,
+                    Box::new(e),
+                )
+            })?;
+            let mut removed = false;
+            if let Some(tasks) = run["tasks"].as_array_mut() {
+                let ids: Vec<String> = tasks
+                    .iter()
+                    .filter(|task| task["sessionId"] == session_id)
+                    .filter_map(|task| task["id"].as_str().map(str::to_string))
+                    .collect();
+                let before = tasks.len();
+                tasks.retain(|task| task["sessionId"] != session_id);
+                removed = before != tasks.len();
+                if removed {
+                    for task in tasks {
+                        if let Some(deps) = task["dependsOn"].as_array_mut() {
+                            deps.retain(|dep| !ids.iter().any(|id| dep == id));
+                        }
+                        // Removing a prerequisite must not release queued work.
+                        // The app stops the run before deleting any current member.
+                        if matches!(
+                            task["status"].as_str(),
+                            Some("queued" | "running" | "cancelling")
+                        ) {
+                            task["status"] = json!("cancelled");
+                            task["accepted"] = json!(false);
+                            task["delivered"] = json!(true);
+                        }
+                    }
+                }
+            }
+            if removed {
+                if matches!(run["status"].as_str(), Some("active" | "paused")) {
+                    run["status"] = json!("stopped");
+                    run["error"] =
+                        json!("A worker conversation was deleted. Start a new run to continue.");
+                }
+                run["requests"] = json!({});
+                tx.execute(
+                    "UPDATE orchestration_runs SET state = ?1 WHERE lead_id = ?2",
+                    params![run.to_string(), parent],
+                )?;
+                index_orchestration(&tx, &parent, &run)?;
+            }
+        }
+        // Also handle summaries left by an older client without a run record.
+        if let Some(mut summary) = orchestration_summary(&tx, &parent)? {
+            if let Some(tasks) = summary["tasks"].as_array_mut() {
+                tasks.retain(|task| task["sessionId"] != session_id);
+            }
+            tx.execute(
+                "UPDATE orchestration_sidebar SET summary = ?1 WHERE lead_id = ?2",
+                params![summary.to_string(), parent],
+            )?;
+        }
+    }
+    tx.execute(
+        "DELETE FROM orchestration_workers WHERE session_id = ?1 OR lead_id = ?1",
+        [session_id],
+    )?;
+    tx.execute("DELETE FROM sessions WHERE id = ?1", [session_id])?;
+    tx.commit()
 }
 
 fn set_archived(conn: &Connection, session_id: &str, archived: bool) -> rusqlite::Result<()> {
@@ -1123,6 +1365,7 @@ fn get_session(conn: &Connection, session_id: &str) -> rusqlite::Result<Option<S
             })?;
             Ok(SessionRecord {
                 id: row.get(0)?,
+                orchestration_lead_id: worker_parent(conn, session_id)?,
                 cwd: row.get(1)?,
                 harness: row.get(2)?,
                 model: row.get(3)?,
@@ -1285,6 +1528,90 @@ mod tests {
         assert_eq!(count, 2);
     }
 
+    #[test]
+    fn orchestration_history_groups_workers_and_keeps_their_transcripts() {
+        let store = SessionStore::open_in_memory().unwrap();
+        let conn = store.conn.lock().unwrap();
+        for id in ["lead", "worker-a", "worker-b", "unrelated"] {
+            upsert_session(&conn, &sample(id, "/tmp/a", id)).unwrap();
+        }
+        let run = json!({"status": "active", "tasks": [
+            {"sessionId": "worker-a", "title": "UI", "harness": "codex", "model": "one", "status": "running", "prompt": "private instructions", "result": "large result"},
+            {"sessionId": "worker-b", "title": "Tests", "harness": "claude", "model": "two", "status": "queued"}
+        ]});
+        save_orchestration(&conn, "lead", &run).unwrap();
+        // Reopening/migration must not hydrate, pause or otherwise mutate runs.
+        migrate(&conn).unwrap();
+        let rows = list_by_project(&conn, "/tmp/a").unwrap();
+        assert_eq!(rows.len(), 2);
+        let lead = rows.iter().find(|row| row.id == "lead").unwrap();
+        let summary = lead.orchestration.as_ref().unwrap();
+        assert_eq!(summary["tasks"].as_array().unwrap().len(), 2);
+        assert_eq!(summary["status"], "active");
+        assert!(summary["tasks"][0].get("prompt").is_none());
+        assert!(summary["tasks"][0].get("result").is_none());
+        let worker = get_session(&conn, "worker-a").unwrap().unwrap();
+        assert_eq!(worker.orchestration_lead_id.as_deref(), Some("lead"));
+        assert!(has_user_block(&worker.blocks));
+        // A later run replaces the card's agents without resurfacing old chats.
+        save_orchestration(&conn, "lead", &json!({"status": "active", "tasks": []})).unwrap();
+        assert_eq!(list_by_project(&conn, "/tmp/a").unwrap().len(), 2);
+    }
+
+    #[test]
+    fn worker_upserts_carry_ownership_before_the_run_is_saved() {
+        let store = SessionStore::open_in_memory().unwrap();
+        let conn = store.conn.lock().unwrap();
+        let mut worker = sample("worker", "/tmp/a", "Worker");
+        worker.blocks =
+            json!([{"id": "u", "role": "user", "text": "Task", "orchestrationLeadId": "lead"}]);
+        worker.linked_work_item = Some(json!({"kind": "pr", "number": 1}));
+        let summary = upsert_session(&conn, &worker).unwrap();
+        assert_eq!(summary.orchestration_lead_id.as_deref(), Some("lead"));
+        assert!(list_by_project(&conn, "/tmp/a").unwrap().is_empty());
+        assert!(list_linked(&conn).unwrap().is_empty());
+        // An older renderer's next write cannot accidentally detach a worker.
+        worker.blocks = json!([{"id": "u", "role": "user", "text": "Task"}]);
+        upsert_session(&conn, &worker).unwrap();
+        assert!(list_by_project(&conn, "/tmp/a").unwrap().is_empty());
+    }
+
+    #[test]
+    fn migration_groups_workers_from_the_earlier_preview() {
+        let store = SessionStore::open_in_memory().unwrap();
+        let conn = store.conn.lock().unwrap();
+        for id in ["lead", "old-worker", "current-worker"] {
+            upsert_session(&conn, &sample(id, "/tmp/a", id)).unwrap();
+        }
+        conn.execute(
+            "UPDATE sessions SET blocks_json = ?1 WHERE id = 'old-worker'",
+            [
+                json!([{"role": "user", "orchestrationLeadId": "lead", "text": "Old task"}])
+                    .to_string(),
+            ],
+        )
+        .unwrap();
+        conn.execute("INSERT INTO orchestration_runs(lead_id, state) VALUES ('lead', ?1)", [json!({"status": "paused", "tasks": [{"sessionId": "current-worker", "title": "Task", "harness": "codex", "model": "one", "status": "completed"}]}).to_string()]).unwrap();
+        conn.execute_batch("DROP TABLE orchestration_sidebar; DROP TABLE orchestration_workers;")
+            .unwrap();
+        migrate(&conn).unwrap();
+        let rows = list_by_project(&conn, "/tmp/a").unwrap();
+        assert_eq!(rows.len(), 1);
+        assert_eq!(rows[0].id, "lead");
+        assert_eq!(
+            rows[0].orchestration.as_ref().unwrap()["tasks"][0]["title"],
+            "Task"
+        );
+        assert_eq!(
+            worker_parent(&conn, "old-worker").unwrap().as_deref(),
+            Some("lead")
+        );
+        assert_eq!(
+            worker_parent(&conn, "current-worker").unwrap().as_deref(),
+            Some("lead")
+        );
+    }
+
     /// The sidebar query must stay answerable from the index alone. Selecting a
     /// column the index does not carry silently reintroduces a table seek per
     /// row, and every summary column sits behind a ~180 KB `blocks_json` blob
@@ -1299,11 +1626,13 @@ mod tests {
                 "EXPLAIN QUERY PLAN
                  SELECT id, cwd, harness, model, runtime_mode, title, provider_session_id,
                         created_at, updated_at, branch, archived, pinned,
-                        linked_work_item_json
+                        linked_work_item_json,
+                        (SELECT summary FROM orchestration_sidebar WHERE lead_id = sessions.id)
                  FROM sessions
                  WHERE cwd = ?1
                    AND has_user_message = 1
                    AND id NOT IN (SELECT id FROM sessions WHERE inbox_ask IS NOT NULL)
+                   AND id NOT IN (SELECT session_id FROM orchestration_workers)
                  ORDER BY updated_at DESC, id ASC",
                 params!["/tmp/a"],
                 |row| row.get(3),
@@ -1533,6 +1862,137 @@ mod tests {
         assert!(list_by_project(&conn, "/tmp/a").unwrap().is_empty());
     }
 
+    #[test]
+    fn deleting_a_lead_releases_current_and_earlier_workers() {
+        let store = SessionStore::open_in_memory().unwrap();
+        let conn = store.conn.lock().unwrap();
+        for id in ["lead", "earlier", "current", "other-lead", "other-worker"] {
+            let mut session = sample(id, "/tmp/a", id);
+            session.linked_work_item = Some(json!({"kind": "pr", "number": 1}));
+            if ["earlier", "current"].contains(&id) {
+                session.blocks = json!([{"id":"u","role":"user","text":"Keep this transcript","orchestrationLeadId":"lead"}]);
+            }
+            upsert_session(&conn, &session).unwrap();
+        }
+        save_orchestration(
+            &conn,
+            "lead",
+            &json!({"status":"stopped","tasks":[{"id":"task","sessionId":"current"}]}),
+        )
+        .unwrap();
+        let other =
+            json!({"status":"active","tasks":[{"id":"other-task","sessionId":"other-worker"}]});
+        save_orchestration(&conn, "other-lead", &other).unwrap();
+        delete_session(&conn, "lead").unwrap();
+
+        for id in ["earlier", "current"] {
+            let worker = get_session(&conn, id).unwrap().unwrap();
+            assert!(worker.orchestration_lead_id.is_none());
+            assert!(worker.blocks[0].get("orchestrationLeadId").is_none());
+            assert_eq!(worker.blocks[0]["text"], "Keep this transcript");
+            assert!(list_by_project(&conn, "/tmp/a")
+                .unwrap()
+                .iter()
+                .any(|row| row.id == id));
+            assert!(list_linked(&conn).unwrap().iter().any(|row| row.id == id));
+        }
+        assert!(orchestration_summary(&conn, "lead").unwrap().is_none());
+        let count: i64 = conn
+            .query_row(
+                "SELECT COUNT(*) FROM orchestration_runs WHERE lead_id = 'lead'",
+                [],
+                |row| row.get(0),
+            )
+            .unwrap();
+        assert_eq!(count, 0);
+        assert_eq!(
+            worker_parent(&conn, "other-worker").unwrap().as_deref(),
+            Some("other-lead")
+        );
+        let raw: String = conn
+            .query_row(
+                "SELECT state FROM orchestration_runs WHERE lead_id = 'other-lead'",
+                [],
+                |row| row.get(0),
+            )
+            .unwrap();
+        assert_eq!(serde_json::from_str::<Value>(&raw).unwrap(), other);
+        migrate(&conn).unwrap();
+        assert!(worker_parent(&conn, "current").unwrap().is_none());
+    }
+
+    #[test]
+    fn deleting_a_worker_prunes_parent_state_and_does_not_release_dependencies() {
+        let store = SessionStore::open_in_memory().unwrap();
+        let conn = store.conn.lock().unwrap();
+        for id in ["lead", "worker", "dependent", "earlier"] {
+            upsert_session(&conn, &sample(id, "/tmp/a", id)).unwrap();
+        }
+        remember_worker(&conn, "earlier", "lead").unwrap();
+        save_orchestration(
+            &conn,
+            "lead",
+            &json!({"status":"active", "requests":{"old":{"result":"worker"}}, "tasks":[
+                {"id":"task", "sessionId":"worker", "status":"running", "dependsOn":[]},
+                {"id":"next", "sessionId":"dependent", "status":"queued", "dependsOn":["task"]}
+            ]}),
+        )
+        .unwrap();
+        delete_session(&conn, "worker").unwrap();
+        assert!(get_session(&conn, "worker").unwrap().is_none());
+        assert!(worker_parent(&conn, "worker").unwrap().is_none());
+        assert_eq!(
+            worker_parent(&conn, "earlier").unwrap().as_deref(),
+            Some("lead")
+        );
+        let raw: String = conn
+            .query_row(
+                "SELECT state FROM orchestration_runs WHERE lead_id = 'lead'",
+                [],
+                |row| row.get(0),
+            )
+            .unwrap();
+        let run: Value = serde_json::from_str(&raw).unwrap();
+        assert_eq!(run["status"], "stopped");
+        assert_eq!(run["requests"], json!({}));
+        assert_eq!(run["tasks"].as_array().unwrap().len(), 1);
+        assert_eq!(run["tasks"][0]["sessionId"], "dependent");
+        assert_eq!(run["tasks"][0]["status"], "cancelled");
+        assert_eq!(run["tasks"][0]["dependsOn"], json!([]));
+        let summary = orchestration_summary(&conn, "lead").unwrap().unwrap();
+        assert_eq!(summary["tasks"].as_array().unwrap().len(), 1);
+        assert_eq!(summary["tasks"][0]["sessionId"], "dependent");
+        assert_eq!(summary["tasks"][0]["status"], "cancelled");
+    }
+
+    #[test]
+    fn failed_session_deletion_rolls_back_orchestration_cleanup() {
+        let store = SessionStore::open_in_memory().unwrap();
+        let conn = store.conn.lock().unwrap();
+        for id in ["lead", "worker"] {
+            upsert_session(&conn, &sample(id, "/tmp/a", id)).unwrap();
+        }
+        save_orchestration(
+            &conn,
+            "lead",
+            &json!({"status":"stopped", "tasks":[{"id":"task", "sessionId":"worker"}]}),
+        )
+        .unwrap();
+        conn.execute_batch("CREATE TRIGGER reject_delete BEFORE DELETE ON sessions BEGIN SELECT RAISE(ABORT, 'test failure'); END;").unwrap();
+        for id in ["lead", "worker"] {
+            assert!(delete_session(&conn, id).is_err());
+            assert!(get_session(&conn, id).unwrap().is_some());
+            assert_eq!(
+                worker_parent(&conn, "worker").unwrap().as_deref(),
+                Some("lead")
+            );
+            assert_eq!(
+                orchestration_summary(&conn, "lead").unwrap().unwrap()["tasks"][0]["sessionId"],
+                "worker"
+            );
+        }
+    }
+
     #[test]
     fn migration_v6_adds_archived_column() {
         let store = SessionStore::open_in_memory().unwrap();
diff --git a/src/App.tsx b/src/App.tsx
index c357e9e1..0526ce4c 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -1,4 +1,28 @@
 import { invoke } from "@tauri-apps/api/core";
+import { orchestrator, type ControlOutcome } from "./lib/orchestration";
+import { modelsFor } from "./lib/models";
+import { isHarnessAvailable } from "./lib/harness/availability";
+import {
+  completeOrchestrationProposal,
+  orchestrationPlanningPrompt,
+  proposalBlock,
+  validateOrchestrationSettings,
+  withOrchestrationProposal,
+  type OrchestrationProposal,
+} from "./lib/orchestrationPlan";
+import { discoverOrchestrationSettings } from "./lib/orchestrationCatalog";
+import {
+  attachOrchestrationWorkers,
+  consolidateOrchestrationTabs,
+  prepareOrchestrationWorkerDetails,
+  releaseOrchestrationWorker,
+} from "./lib/orchestrationWorkspace";
+import {
+  OrchestrationActions,
+  OrchestrationWorkers,
+  type OrchestrationWorkerDetail,
+} from "./chrome/OrchestrationActions";
+import { flushSync } from "react-dom";
 import { listen } from "@tauri-apps/api/event";
 import { getCurrentWindow } from "@tauri-apps/api/window";
 import { ask, message } from "@tauri-apps/plugin-dialog";
@@ -75,6 +99,7 @@ import {
   nextTerminalTitle,
   openChangesTab,
   openCommitTab,
+  newAgentTab,
   openEditorTab,
   openSessionChangesTab,
   openTerminalTab,
@@ -232,6 +257,7 @@ import {
 } from "./lib/workspaceTabGroups";
 import { runSessionRemoval } from "./lib/sessionRemoval";
 import {
+  HARNESSES,
   HARNESS_LABEL,
   HARNESS_TITLE,
   canReplaceSessionTitle,
@@ -661,6 +687,20 @@ export default function App({
     useState<InboxSessionPortal | null>(null);
   const openingInboxSessions = useRef(new Map<string, Promise<string>>());
   const [notesViewOpen, setNotesViewOpen] = useState(false);
+  const [inspectedWorkerId, setInspectedWorkerId] = useState<string | null>(
+    null,
+  );
+  // Set while the lead's tab is still opening; the agent tab lands on the
+  // commit that brings it in.
+  const [workerDetailRequest, setWorkerDetailRequest] = useState<{
+    leadId: string;
+    workers: OrchestrationWorkerDetail[];
+  } | null>(null);
+  const orchestrationRuns = useSyncExternalStore(
+    orchestrator.subscribe,
+    orchestrator.snapshot,
+    orchestrator.snapshot,
+  );
   const notesEnabled = useSyncExternalStore(
     subscribeNotesEnabled,
     loadNotesEnabled,
@@ -827,6 +867,7 @@ export default function App({
 
   const stopSessionForRemoval = useCallback(
     async (sessionId: string): Promise<Session | undefined> => {
+      await orchestrator.stopForSession(sessionId);
       const open = sessionsRef.current.find(
         (session) => session.id === sessionId,
       );
@@ -990,7 +1031,10 @@ export default function App({
   const nextBusySessionIds = useMemo(() => {
     const ids = new Set<string>();
     for (const session of sessions) {
-      if (session.busy) ids.add(session.id);
+      if (session.busy) {
+        ids.add(session.id);
+        if (session.orchestrationLeadId) ids.add(session.orchestrationLeadId);
+      }
     }
     return ids;
   }, [sessions]);
@@ -1036,7 +1080,10 @@ export default function App({
   const nextApprovalSessionIds = useMemo(() => {
     const ids = new Set<string>();
     for (const session of sessions) {
-      if (sessionNeedsInput(session)) ids.add(session.id);
+      if (sessionNeedsInput(session)) {
+        ids.add(session.id);
+        if (session.orchestrationLeadId) ids.add(session.orchestrationLeadId);
+      }
     }
     return ids;
   }, [sessions]);
@@ -1383,6 +1430,20 @@ export default function App({
     for (const session of sessions) {
       if (session.inboxAsk) visibleIds.add(session.id);
     }
+    // Internal workers stay attached to the lead, even while idle between
+    // turns. They must not be discarded merely because they have no tab.
+    for (const session of sessions) {
+      if (
+        session.orchestrationLeadId &&
+        (visibleIds.has(session.orchestrationLeadId) ||
+          orchestrationRuns.some(
+            (run) =>
+              run.leadId === session.orchestrationLeadId &&
+              ["active", "paused"].includes(run.status),
+          ))
+      )
+        visibleIds.add(session.id);
+    }
     for (const sessionId of visibleIds) {
       openingSessionIds.current.delete(sessionId);
       loadedSessionCache.current.delete(sessionId);
@@ -1416,12 +1477,13 @@ export default function App({
           skipForgetSessionIds.current.has(session.id),
       ),
     );
-  }, [sessions, tabs, persistSession, liveAgentsEnabled]);
+  }, [sessions, tabs, persistSession, liveAgentsEnabled, orchestrationRuns]);
 
   const activateTab = useCallback((id: string, paneId?: string) => {
     const tab = tabsRef.current.find((entry) => entry.id === id);
     const nextFocusedId =
-      tab && paneId &&
+      tab &&
+      paneId &&
       (leafIds(tab.layout).includes(paneId) ||
         tab.editorPanes.some((entry) => entry.id === paneId) ||
         (tab.terminalPanes ?? []).some((entry) => entry.id === paneId))
@@ -3197,29 +3259,30 @@ export default function App({
 
   const onSelectHistorySession = useCallback(
     async (sessionId: string) => {
-      const linkedUpdate = linkedSessionUpdatesRef.current.get(sessionId);
-      if (focusOpenSession(sessionId)) {
-        if (linkedUpdate) revealLinkedSessionUpdate(sessionId, linkedUpdate);
-        return;
-      }
-      const session = await ensureOpenSession(sessionId);
+      let session = await ensureOpenSession(sessionId);
       if (!session || session.inboxAsk) return;
-      // A previous race may have left this tab pointing at a parked session.
-      // Once the session is restored, reuse that tab instead of creating a
-      // duplicate and leave the broken pane behind.
-      if (focusOpenSession(sessionId)) {
-        if (linkedUpdate) revealLinkedSessionUpdate(sessionId, linkedUpdate);
+      const parentId =
+        session.orchestrationLeadId ??
+        orchestrator.forSession(sessionId)?.leadId;
+      if (parentId && parentId !== sessionId) {
+        setInspectedWorkerId(sessionId);
+        session = await ensureOpenSession(parentId);
+        if (!session) return;
+      }
+      const linkedUpdate = linkedSessionUpdatesRef.current.get(session.id);
+      if (focusOpenSession(session.id)) {
+        if (linkedUpdate) revealLinkedSessionUpdate(session.id, linkedUpdate);
         return;
       }
       if (replaceBlankPaneWithSession(session)) {
-        if (linkedUpdate) revealLinkedSessionUpdate(sessionId, linkedUpdate);
+        if (linkedUpdate) revealLinkedSessionUpdate(session.id, linkedUpdate);
         return;
       }
       const tab = newTab(session.id);
       appendTab(tab, session.cwd);
       setActiveTabId(tab.id);
       setComposerFocused(true);
-      if (linkedUpdate) revealLinkedSessionUpdate(sessionId, linkedUpdate);
+      if (linkedUpdate) revealLinkedSessionUpdate(session.id, linkedUpdate);
     },
     [
       appendTab,
@@ -3267,7 +3330,9 @@ export default function App({
   const sessionReminders = useSessionReminders(
     openReminderSession,
     ensureReminderSessionsSaved,
-    sessions.filter((session) => !session.inboxAsk).map((session) => session.id),
+    sessions
+      .filter((session) => !session.inboxAsk)
+      .map((session) => session.id),
   );
 
   const dismissNoticesForContinuedSession = useCallback(
@@ -3445,6 +3510,10 @@ export default function App({
             );
           },
           stop: async () => {
+            const run =
+              mode === "delete" ? orchestrator.forSession(sessionId) : undefined;
+            if (run && (run.status === "active" || run.status === "paused"))
+              await orchestrator.stopRun(run.leadId);
             await stopSessionForRemoval(sessionId);
           },
           updateSession: (stopped) => {
@@ -3457,7 +3526,33 @@ export default function App({
           persist: async (latest) => {
             if (latest) await flushSessionCheckpoint(sessionId);
             if (mode === "delete") {
-              await deleteSession(sessionId);
+              await orchestrator.deleteSession(sessionId, () =>
+                deleteSession(sessionId),
+              );
+              const released = sessionsRef.current.map((session) =>
+                releaseOrchestrationWorker(session, sessionId),
+              );
+              sessionsRef.current = released;
+              setSessions(released);
+              for (const [id, cached] of loadedSessionCache.current) {
+                if (releaseOrchestrationWorker(cached, sessionId) !== cached)
+                  invalidateLoadedSession(id);
+              }
+              // Pending reads may still carry the deleted lead's ownership.
+              for (const id of sessionLoads.current.keys())
+                invalidateLoadedSession(id);
+              for (const [id, pending] of pendingPersist.current) {
+                pendingPersist.current.set(
+                  id,
+                  releaseOrchestrationWorker(pending, sessionId),
+                );
+              }
+              const releaseSummary = (entry: SessionSummary) =>
+                entry.orchestrationLeadId === sessionId
+                  ? { ...entry, orchestrationLeadId: undefined }
+                  : entry;
+              setHistory((current) => current.map(releaseSummary));
+              setStoredLinkedSessions((current) => current.map(releaseSummary));
               return;
             }
             if (latest && shouldPersistSession(latest)) {
@@ -4210,8 +4305,36 @@ export default function App({
         intent?: TurnIntent;
         planBlockId?: string;
         buildTarget?: PlanBuildTarget;
+        managed?: boolean;
+        onSettled?: (outcome: ControlOutcome) => void;
       },
     ) => {
+      const controlError = orchestrator.submissionError(
+        sessionId,
+        options?.managed,
+      );
+      if (controlError) {
+        enqueueHarnessEvent(sessionId, { type: "status", text: controlError });
+        flushHarnessEvents();
+        return;
+      }
+      if (options?.managed) {
+        const target = sessionsRef.current.find((s) => s.id === sessionId);
+        if (
+          !target ||
+          target.busy ||
+          target.pendingSwitch ||
+          isPreparingHandoff(target) ||
+          removingSessionIds.current.has(sessionId)
+        ) {
+          options.onSettled?.({
+            status: "failed",
+            text: "",
+            error: "Session is unavailable or already running",
+          });
+          return;
+        }
+      }
       if (removingSessionIds.current.has(sessionId)) return;
       const storedCurrent = sessionsRef.current.find((s) => s.id === sessionId);
       if (!storedCurrent) return;
@@ -4219,6 +4342,22 @@ export default function App({
         ? withPlanBuildTarget(storedCurrent, options.buildTarget)
         : storedCurrent;
       const intent = options?.intent ?? "default";
+      if (intent === "orchestrate") {
+        try {
+          const run = orchestrator.forSession(sessionId);
+          if (run && ["active", "paused"].includes(run.status))
+            throw new Error(
+              "Stop the current orchestration run before preparing another proposal.",
+            );
+        } catch (error) {
+          enqueueHarnessEvent(sessionId, {
+            type: "status",
+            text: error instanceof Error ? error.message : String(error),
+          });
+          flushHarnessEvents();
+          return;
+        }
+      }
       const approvedPlan = options?.planBlockId
         ? current.blocks.find(
             (block) =>
@@ -4263,7 +4402,7 @@ export default function App({
 
       if (current.busy && !pendingSwitch) {
         const followUpBehavior =
-          intent === "plan"
+          intent === "plan" || intent === "orchestrate"
             ? "queue"
             : (options?.followUpBehavior ?? loadFollowUpBehavior());
         if (followUpBehavior === "queue") {
@@ -4363,6 +4502,26 @@ export default function App({
 
       const gen = (turnGen.current.get(sessionId) ?? 0) + 1;
       turnGen.current.set(sessionId, gen);
+      const proposalId =
+        intent === "orchestrate" ? crypto.randomUUID() : undefined;
+      let proposalDraft: OrchestrationProposal | undefined = proposalId
+        ? {
+            version: 1,
+            leadId: sessionId,
+            cwd: current.cwd,
+            request: harnessText,
+            author: {
+              harness: current.harness,
+              model: current.model,
+              name: resolveModel(current.harness, current.model).name,
+            },
+            settings: { choices: [], maxWorkers: 2 },
+            status: "planning",
+            title: "Orchestration plan",
+            summary: "",
+            tasks: [],
+          }
+        : undefined;
       const isFirstTurn = current.blocks.length === 0;
       const placeholderTitle = canReplaceSessionTitle(
         current.title,
@@ -4386,7 +4545,11 @@ export default function App({
           : card
             ? SECOND_OPINION_TITLE
             : submittedText;
-      const cards = rawCommand ? undefined : userTurnCards(noteCard, card);
+      const cards = {
+        ...(rawCommand ? undefined : userTurnCards(noteCard, card)),
+        // The orchestrator writes these turns, not the user; hide them.
+        ...(options?.managed ? { internal: true } : {}),
+      };
       const live = isLiveHarness(current.harness);
       const queuedHandoff =
         live && !pendingSwitch ? pendingHandoff(current) : null;
@@ -4516,10 +4679,50 @@ export default function App({
         if (pendingSwitch) {
           void forgetHarnessSession(pendingSwitch.from, sessionId);
         }
+        options?.onSettled?.({
+          status: "failed",
+          text: "",
+          error: "Harness is not connected",
+        });
         return;
       }
 
+      if (proposalId && proposalDraft) {
+        const draft = proposalDraft;
+        setSessions((prev) =>
+          prev.map((session) =>
+            session.id === sessionId
+              ? {
+                  ...session,
+                  blocks: [...session.blocks, proposalBlock(proposalId, draft)],
+                }
+              : session,
+          ),
+        );
+      }
+
+      let controlOutcome: ControlOutcome = {
+        status: "failed",
+        text: "",
+        error: "Turn did not complete",
+      };
+      let controlText = "";
+      let proposalText = "";
+      let nativeProposalText = "";
       void (async () => {
+        if (proposalDraft && proposalId) {
+          const settings = await discoverOrchestrationSettings();
+          if (turnGen.current.get(sessionId) !== gen) return;
+          proposalDraft = { ...proposalDraft, settings };
+          const discovering = proposalDraft;
+          setSessions((prev) =>
+            prev.map((session) =>
+              session.id === sessionId
+                ? withOrchestrationProposal(session, proposalId, discovering)
+                : session,
+            ),
+          );
+        }
         let wrap = handoffCard
           ? {
               from: handoffCard.from,
@@ -4571,6 +4774,22 @@ export default function App({
         let providerFailureSeen = false;
         const routePlanEvent = (event: HarnessEvent): HarnessEvent | null => {
           if (event.type === "session.error") providerFailureSeen = true;
+          if (proposalDraft) {
+            if (event.type === "message.delta") {
+              proposalText = (proposalText + event.text).slice(-200_000);
+              return null;
+            }
+            if (event.type === "message.completed") {
+              proposalText += "\n";
+              return null;
+            }
+            if (event.type === "plan") {
+              nativeProposalText = event.append
+                ? nativeProposalText + event.text
+                : event.text;
+              return null;
+            }
+          }
           if (intent !== "plan") return event;
           if (event.type === "plan") {
             nativePlanSeen = true;
@@ -4582,7 +4801,7 @@ export default function App({
           return event;
         };
 
-        if (!current.inboxAsk) {
+        if (!current.inboxAsk && !orchestrator.forSession(sessionId)) {
           await beginSessionTurn(sessionId, workCwd).catch(() => undefined);
         }
         if (turnGen.current.get(sessionId) !== gen) return;
@@ -4597,8 +4816,11 @@ export default function App({
                   sessionId,
                   cwd: workCwd,
                 });
-          const turnPrompt =
-            intent === "plan" && !rawCommand ? planTurnPrompt(prompt) : prompt;
+          const turnPrompt = proposalDraft
+            ? orchestrationPlanningPrompt(prompt, proposalDraft.settings)
+            : intent === "plan" && !rawCommand
+              ? planTurnPrompt(prompt)
+              : prompt;
           const earlier = queuedHandoff
             ? userMessagesAfterHandoff(current)
             : [];
@@ -4609,21 +4831,34 @@ export default function App({
             model: current.model,
             modelSettings: current.modelSettings,
             runtimeMode: current.runtimeMode,
-            intent,
-            text: inboxAskPrompt(
-              rawCommand ? undefined : current.inboxAsk,
-              wrap && !rawCommand
-                ? wrapHandoffPrompt(
-                    wrap.text,
-                    wrap.from,
-                    turnPrompt.trim() || CONTINUE_PROMPT,
-                    earlier,
-                  )
-                : turnPrompt,
+            intent: intent === "orchestrate" ? "plan" : intent,
+            // A lead drives the control CLI over loopback; without this the
+            // harness sandbox denies the socket and it cannot supervise.
+            controlsAgents: orchestrator.run(sessionId)?.status === "active",
+            text: orchestrator.prompt(
+              sessionId,
+              inboxAskPrompt(
+                rawCommand ? undefined : current.inboxAsk,
+                wrap && !rawCommand
+                  ? wrapHandoffPrompt(
+                      wrap.text,
+                      wrap.from,
+                      turnPrompt.trim() || CONTINUE_PROMPT,
+                      earlier,
+                    )
+                  : turnPrompt,
+              ),
             ),
             attachments: prepared,
             onEvent: (event) => {
               if (turnGen.current.get(sessionId) !== gen) return;
+              orchestrator.observe(sessionId, event);
+              if (options?.onSettled && event.type === "message.delta")
+                controlText = (controlText + event.text).slice(-20_000);
+              if (options?.onSettled && event.type === "message.completed")
+                controlText += "\n";
+              if (event.type === "session.error")
+                controlOutcome.error = event.message;
               if (
                 wrap &&
                 (event.type === "session.started" ||
@@ -4632,7 +4867,8 @@ export default function App({
                 revealHandoff(wrap.text);
               }
               nudgeOpenEditors(event, workCwd);
-              trackSessionEdits(sessionId, workCwd, event);
+              if (!orchestrator.forSession(sessionId))
+                trackSessionEdits(sessionId, workCwd, event);
               const routed = routePlanEvent(event);
               if (routed) enqueueHarnessEvent(sessionId, routed);
             },
@@ -4658,6 +4894,7 @@ export default function App({
             error instanceof Error
               ? error.message
               : `${current.harness} adapter failed`;
+          controlOutcome.error = message;
           if (!providerFailureSeen) {
             enqueueHarnessEvent(sessionId, {
               type: "session.error",
@@ -4668,6 +4905,16 @@ export default function App({
         } finally {
           if (turnGen.current.get(sessionId) !== gen) return;
           flushHarnessEvents();
+          controlOutcome = {
+            status:
+              providerFailureSeen ||
+              isProviderFailureText(controlText) ||
+              !buildSucceeded
+                ? "failed"
+                : "completed",
+            text: controlText.trim(),
+            ...(providerFailureSeen ? { error: controlOutcome.error } : {}),
+          };
           // A failed provider can leave its process alive with a dead event
           // stream or poisoned turn state. Park it now; the next prompt will
           // reconnect and resume through a fresh transport.
@@ -4685,9 +4932,22 @@ export default function App({
                 providerFailureSeen ||
                 isProviderFailureText(lastAssistantTextInTurn(stopped));
               const finalized =
-                intent === "plan" && !nativePlanSeen && !providerFailed
-                  ? promoteLastAssistantToPlan(stopped, planEventKey)
-                  : stopped;
+                proposalDraft && proposalId
+                  ? withOrchestrationProposal(
+                      stopped,
+                      proposalId,
+                      completeOrchestrationProposal(
+                        proposalDraft,
+                        nativeProposalText || proposalText,
+                        providerFailed || !buildSucceeded
+                          ? (controlOutcome.error ??
+                              "The lead could not finish planning.")
+                          : undefined,
+                      ),
+                    )
+                  : intent === "plan" && !nativePlanSeen && !providerFailed
+                    ? promoteLastAssistantToPlan(stopped, planEventKey)
+                    : stopped;
               return approvedPlan && intent === "build"
                 ? withPlanStatus(
                     finalized,
@@ -4717,7 +4977,45 @@ export default function App({
           nudgeWatchedFiles();
           window.setTimeout(() => nudgeWatchedFiles(), 150);
         }
-      })();
+      })()
+        .catch((error: unknown) => {
+          controlOutcome = {
+            status: "failed",
+            text: controlText,
+            error: error instanceof Error ? error.message : String(error),
+          };
+          if (turnGen.current.get(sessionId) === gen) {
+            enqueueHarnessEvent(sessionId, {
+              type: "session.error",
+              message: controlOutcome.error!,
+            });
+            flushHarnessEvents();
+            setSessions((prev) =>
+              prev.map((session) =>
+                session.id === sessionId
+                  ? proposalId && proposalDraft
+                    ? withOrchestrationProposal(
+                        stopStreaming(session),
+                        proposalId,
+                        completeOrchestrationProposal(
+                          proposalDraft,
+                          "",
+                          controlOutcome.error,
+                        ),
+                      )
+                    : stopStreaming(session)
+                  : session,
+              ),
+            );
+          }
+        })
+        .finally(() => {
+          options?.onSettled?.(
+            turnGen.current.get(sessionId) !== gen
+              ? { status: "cancelled", text: controlText }
+              : controlOutcome,
+          );
+        });
     },
     [
       dismissNoticesForContinuedSession,
@@ -4772,6 +5070,7 @@ export default function App({
         !session ||
         session.busy ||
         block?.role !== "plan" ||
+        !!block.orchestration ||
         !block.text.trim() ||
         block.plan?.status === "streaming" ||
         block.plan?.status === "building" ||
@@ -4903,14 +5202,23 @@ export default function App({
         ? queuedMessageForSubmit(session, messageId, "steer")
         : undefined;
       if (!session || !message) return;
+      if (message.intent === "orchestrate" && session.busy) {
+        enqueueHarnessEvent(sessionId, {
+          type: "status",
+          text: "Orchestration planning will start after the current turn finishes.",
+        });
+        flushHarnessEvents();
+        return;
+      }
       onSubmit(sessionId, message.text, message.attachments, {
         followUpBehavior: "steer",
         queuedMessageId: message.id,
         noteCard: message.noteCard,
         handoffCard: message.handoffCard,
+        intent: message.intent,
       });
     },
-    [onSubmit],
+    [onSubmit, enqueueHarnessEvent, flushHarnessEvents],
   );
 
   const onResumeQueue = useCallback(
@@ -5153,7 +5461,14 @@ export default function App({
   );
 
   const onStop = useCallback(
-    (sessionId: string) => {
+    (sessionId: string, managed = false) => {
+      if (!managed) {
+        const stopping = orchestrator.stopForSession(sessionId);
+        if (stopping) {
+          void stopping.catch(console.error);
+          return;
+        }
+      }
       const session = sessionsRef.current.find((s) => s.id === sessionId);
       turnGen.current.set(sessionId, (turnGen.current.get(sessionId) ?? 0) + 1);
       flushHarnessEvents();
@@ -5252,20 +5567,414 @@ export default function App({
   const onQuestionInteraction = useCallback(
     (sessionId: string, requestId: number) => {
       const session = sessionsRef.current.find((s) => s.id === sessionId);
-      if (session) keepHarnessQuestionOpen(session.harness, sessionId, requestId);
+      if (session)
+        keepHarnessQuestionOpen(session.harness, sessionId, requestId);
     },
     [],
   );
 
   const onOpenApprovalSession = useCallback(
     (sessionId: string) => {
-      if (!focusOpenSession(sessionId)) {
+      const parentId =
+        sessionsRef.current.find((session) => session.id === sessionId)
+          ?.orchestrationLeadId ?? orchestrator.forSession(sessionId)?.leadId;
+      if (parentId && parentId !== sessionId) {
+        setInspectedWorkerId(sessionId);
+        if (!focusOpenSession(parentId)) void onSelectHistorySession(parentId);
+      } else if (!focusOpenSession(sessionId)) {
         void onSelectHistorySession(sessionId);
       }
     },
     [focusOpenSession, onSelectHistorySession],
   );
 
+  useEffect(() => {
+    setSessions((prev) => attachOrchestrationWorkers(prev, orchestrationRuns));
+  }, [orchestrationRuns]);
+
+  useEffect(() => {
+    const next = consolidateOrchestrationTabs(
+      tabs,
+      activeTabId,
+      orchestrationRuns,
+    );
+    if (next.tabs !== tabs) setTabs(next.tabs);
+    if (next.activeTabId !== activeTabId) setActiveTabId(next.activeTabId);
+  }, [tabs, activeTabId, orchestrationRuns]);
+
+  useLayoutEffect(() => {
+    orchestrator.bind({
+      session: (id) => sessionsRef.current.find((session) => session.id === id),
+      sessions: () => sessionsRef.current,
+      choices: () =>
+        HARNESSES.filter(isHarnessAvailable).map((harness) => ({
+          harness,
+          models: modelsFor(harness).map(({ id, name }) => ({ id, name })),
+        })),
+      createWorker: async (run, task) => {
+        await invoke("control_attach_worker", {
+          leadId: run.leadId,
+          sessionId: task.sessionId,
+        });
+        const existing = sessionsRef.current.find(
+          (session) => session.id === task.sessionId,
+        );
+        const lead = sessionsRef.current.find(
+          (session) => session.id === run.leadId,
+        );
+        if (!lead) throw new Error("Lead session is unavailable");
+        if (existing) {
+          if (
+            existing.harness !== task.harness ||
+            existing.model !== task.model ||
+            existing.cwd !== run.cwd
+          )
+            throw new Error(
+              "This worker's configuration changed. Restore its approved harness, model and project before retrying.",
+            );
+          // The lead's runtime mode governs its agents, including across a
+          // change mid-run: auto stays auto, supervised asks the lead.
+          if (existing.runtimeMode !== lead.runtimeMode) {
+            const synced = { ...existing, runtimeMode: lead.runtimeMode };
+            await upsertSession(synced);
+            const next = sessionsRef.current.map((session) =>
+              session.id === synced.id ? synced : session,
+            );
+            sessionsRef.current = next;
+            setSessions(next);
+          }
+          return;
+        }
+        const restored = await getSession(task.sessionId);
+        if (
+          restored &&
+          (restored.harness !== task.harness || restored.model !== task.model)
+        )
+          throw new Error(
+            "The saved worker no longer matches its approved model. Create a new assignment.",
+          );
+        const base = restored
+          ? {
+              ...restored,
+              busy: false,
+              cwd: run.cwd,
+              worktreeCwd: undefined,
+              runtimeMode: lead.runtimeMode,
+            }
+          : {
+              ...newSession(
+                task.harness,
+                run.cwd,
+                task.model,
+                lead.runtimeMode,
+              ),
+              id: task.sessionId,
+              title: task.title,
+            };
+        const worker = { ...base, orchestrationLeadId: run.leadId };
+        if (worker.providerSessionId)
+          bindHarnessSession(
+            worker.harness,
+            worker.id,
+            worker.providerSessionId,
+            worker.cwd,
+          );
+        await upsertSession(worker);
+        const next = [...sessionsRef.current, worker];
+        sessionsRef.current = next;
+        setSessions(next);
+        // Workers belong to the lead's agent panel; no workspace tab is created.
+      },
+      submit: (id, text, done) => {
+        // Commit the new turn before the scheduler or confirmation updates
+        // another session snapshot in the same event loop.
+        flushSync(() =>
+          onSubmit(id, text, [], { managed: true, onSettled: done }),
+        );
+      },
+      steer: async (id, text) => {
+        const session = sessionsRef.current.find((entry) => entry.id === id);
+        if (!session) throw new Error("This agent is no longer available");
+        if (!session.busy)
+          throw new Error(
+            "This agent is not running a turn; send it a fresh one with message.",
+          );
+        if (
+          !isLiveHarness(session.harness) ||
+          !canSteerHarness(session.harness)
+        )
+          throw new Error(
+            `${session.harness} cannot take guidance mid-turn. Wait for the turn to finish, then use message.`,
+          );
+        // Record it on the worker before dispatch, so its own transcript shows
+        // why it changed course even if the harness call then fails.
+        const next = sessionsRef.current.map((entry) =>
+          entry.id === id ? appendSteerUser(entry, text) : entry,
+        );
+        sessionsRef.current = next;
+        setSessions(next);
+        await steerHarnessTurn({
+          harness: session.harness,
+          sessionId: id,
+          cwd: sessionWorkCwd(session),
+          model: session.model,
+          modelSettings: session.modelSettings,
+          text,
+        });
+      },
+      respondApproval: (id, requestId, decision) => {
+        const session = sessionsRef.current.find((entry) => entry.id === id);
+        if (session)
+          respondHarnessApproval(session.harness, id, requestId, decision);
+      },
+      answerQuestion: (id, requestId, reply) => {
+        const session = sessionsRef.current.find((entry) => entry.id === id);
+        if (session)
+          respondHarnessQuestion(session.harness, id, requestId, reply);
+      },
+      stop: async (id) => {
+        const session = sessionsRef.current.find((entry) => entry.id === id);
+        onStop(id, true);
+        try {
+          if (session)
+            await Promise.all(
+              sessionChildHarnesses(session).map((harness) =>
+                stopHarnessSession(harness, id),
+              ),
+            );
+        } finally {
+          // Also reap processes left behind by a renderer reload, before the
+          // corresponding session has been restored in this window.
+          await invoke("harness_kill", { sessionId: id });
+          await invoke("control_turn_finished", { sessionId: id });
+        }
+      },
+    });
+  }, [onSubmit, onStop]);
+
+  useEffect(() => {
+    orchestrator.sync();
+  }, [sessions]);
+
+  useEffect(() => {
+    const listening = listen<{
+      id: string;
+      sessionId: string;
+      requestId: string;
+      action: string;
+      input: Record<string, unknown>;
+    }>("monocode-control-request", ({ payload }) => {
+      void orchestrator
+        .handle(
+          payload.sessionId,
+          payload.requestId,
+          payload.action,
+          payload.input,
+        )
+        .then(
+          (result) =>
+            invoke("control_reply", {
+              id: payload.id,
+              response: { ok: true, result },
+            }),
+          (error: unknown) =>
+            invoke("control_reply", {
+              id: payload.id,
+              response: {
+                ok: false,
+                error: error instanceof Error ? error.message : String(error),
+              },
+            }),
+        )
+        .catch(console.error);
+    });
+    return () => {
+      void listening.then((unlisten) => unlisten());
+    };
+  }, []);
+
+  const confirmingOrchestration = useRef(new Set<string>());
+  const queueWorkerPanes = useCallback(
+    (workers: OrchestrationWorkerDetail[]) => {
+      // Finished workers are not open; load stored transcripts before the
+      // tabs appear so the pane does not flash the empty state.
+      void prepareOrchestrationWorkerDetails(workers, {
+        openLead: async (leadId) => {
+          if (!focusOpenSession(leadId)) await onSelectHistorySession(leadId);
+        },
+        openWorker: ensureOpenSession,
+        hasSession: (id) =>
+          sessionsRef.current.some((session) => session.id === id),
+      })
+        .then((request) => {
+          if (request?.workers.length) setWorkerDetailRequest(request);
+        })
+        .catch(console.error);
+    },
+    [ensureOpenSession, focusOpenSession, onSelectHistorySession],
+  );
+  const onOpenWorkerDetails = useCallback(
+    (worker: OrchestrationWorkerDetail) => {
+      setInspectedWorkerId(worker.sessionId);
+      queueWorkerPanes([worker]);
+    },
+    [queueWorkerPanes],
+  );
+  useEffect(() => {
+    if (!workerDetailRequest) return;
+    const { leadId, workers } = workerDetailRequest;
+    const tab = tabs.find((entry) => leafIds(entry.layout).includes(leadId));
+    if (!tab) {
+      // Still opening: this runs again on the commit that lands the lead. If
+      // the lead never arrived at all, drop the request rather than let it
+      // fire against some later tab change.
+      if (!sessionsRef.current.some((entry) => entry.id === leadId)) {
+        setWorkerDetailRequest(null);
+      }
+      return;
+    }
+    setWorkerDetailRequest(null);
+    // Every agent of a run shares one pane, the way files do: `openEditorTab`
+    // focuses an open tab, adds to the pane already beside the lead, or splits
+    // one off when there is none.
+    const cwd =
+      sessionsRef.current.find((entry) => entry.id === leadId)?.cwd ??
+      projectCwdRef.current;
+    const files = workers.map((worker) =>
+      newAgentTab(worker.title, cwd, {
+        sessionId: worker.sessionId,
+        leadId,
+        harness: worker.harness,
+      }),
+    );
+    setTabs((prev) =>
+      prev.map((entry) => {
+        if (entry.id !== tab.id) return entry;
+        const opened = files.reduce(
+          (next, file) => openEditorTab(next, file),
+          entry,
+        );
+        // Leave the first worker focused so View agents lands on the start
+        // of the run rather than the last tab added.
+        return files[0] ? openEditorTab(opened, files[0]) : opened;
+      }),
+    );
+    setActiveTabId(tab.id);
+    setComposerFocused(false);
+  }, [tabs, workerDetailRequest]);
+  const orchestrationWorkers = useMemo(
+    () => ({
+      selectedId: inspectedWorkerId,
+      inspect: setInspectedWorkerId,
+      openDetails: onOpenWorkerDetails,
+    }),
+    [inspectedWorkerId, onOpenWorkerDetails],
+  );
+  const updateOrchestrationCard = useCallback(
+    (leadId: string, blockId: string, proposal: OrchestrationProposal) => {
+      const next = sessionsRef.current.map((session) =>
+        session.id === leadId
+          ? withOrchestrationProposal(session, blockId, proposal)
+          : session,
+      );
+      sessionsRef.current = next;
+      setSessions(next);
+      return next.find((session) => session.id === leadId);
+    },
+    [],
+  );
+  const orchestrationActions = useMemo(
+    () => ({
+      open: onOpenApprovalSession,
+      openAgents: queueWorkerPanes,
+      update: (
+        leadId: string,
+        blockId: string,
+        edited: OrchestrationProposal,
+      ) => {
+        const session = sessionsRef.current.find(
+          (entry) => entry.id === leadId,
+        );
+        const proposal = session?.blocks.find(
+          (block) => block.id === blockId,
+        )?.orchestration;
+        if (
+          !session ||
+          session.busy ||
+          proposal?.status !== "ready" ||
+          confirmingOrchestration.current.has(leadId)
+        )
+          return;
+        // Keep the discovered catalog authoritative while allowing task and parallelism edits.
+        const settings = validateOrchestrationSettings({
+          ...proposal.settings,
+          maxWorkers: edited.settings.maxWorkers,
+        });
+        updateOrchestrationCard(leadId, blockId, {
+          ...proposal,
+          settings,
+          tasks: edited.tasks,
+        });
+      },
+      confirm: async (leadId: string, blockId: string) => {
+        if (confirmingOrchestration.current.has(leadId)) return;
+        confirmingOrchestration.current.add(leadId);
+        let proposal: OrchestrationProposal | undefined;
+        try {
+          await orchestrator.hydrate(leadId);
+          const session = sessionsRef.current.find(
+            (entry) => entry.id === leadId,
+          );
+          proposal = session?.blocks.find(
+            (block) => block.id === blockId,
+          )?.orchestration;
+          if (!session || session.busy || proposal?.status !== "ready")
+            throw new Error(
+              "Wait for the proposal to finish before confirming.",
+            );
+          if (
+            session.harness !== proposal.author.harness ||
+            session.model !== proposal.author.model
+          )
+            throw new Error(
+              "The lead model has changed. Switch back to the model shown on this card, or generate a new proposal.",
+            );
+          const starting = updateOrchestrationCard(leadId, blockId, {
+            ...proposal,
+            status: "starting",
+          })!;
+          // Save the edited card before anything can execute.
+          await upsertSession(starting);
+          await orchestrator.startApproved(leadId, blockId, proposal);
+          updateOrchestrationCard(leadId, blockId, {
+            ...proposal,
+            status: "approved",
+          });
+        } catch (error) {
+          if (proposal)
+            updateOrchestrationCard(leadId, blockId, {
+              ...proposal,
+              status: "ready",
+            });
+          throw error;
+        } finally {
+          confirmingOrchestration.current.delete(leadId);
+        }
+      },
+      retry: (leadId: string, blockId: string) => {
+        const session = sessionsRef.current.find(
+          (entry) => entry.id === leadId,
+        );
+        const proposal = session?.blocks.find(
+          (block) => block.id === blockId,
+        )?.orchestration;
+        if (!session || session.busy || !proposal) return;
+        onSubmit(leadId, proposal.request, [], { intent: "orchestrate" });
+      },
+    }),
+    [onOpenApprovalSession, queueWorkerPanes, onSubmit, updateOrchestrationCard],
+  );
+
   const onSelectLiveAgent = useCallback(
     (sessionId: string) => {
       setSearchViewOpen(false);
@@ -5297,15 +6006,21 @@ export default function App({
 
   const sidebarHistory = useMemo(
     () =>
-      historyWithLiveSessions(history, sessions, sidebarCwd, {
-        ...(projectBranches?.current
-          ? { branch: projectBranches.current }
-          : {}),
-        ...(sidebarCwd && sidebarCwd !== "~"
-          ? { repo: projectName(sidebarCwd) }
-          : {}),
-      }),
-    [history, projectBranches, sessions, sidebarCwd],
+      historyWithLiveSessions(
+        history,
+        sessions,
+        sidebarCwd,
+        {
+          ...(projectBranches?.current
+            ? { branch: projectBranches.current }
+            : {}),
+          ...(sidebarCwd && sidebarCwd !== "~"
+            ? { repo: projectName(sidebarCwd) }
+            : {}),
+        },
+        orchestrationRuns,
+      ),
+    [history, projectBranches, sessions, sidebarCwd, orchestrationRuns],
   );
   const {
     unseen: inboxUnseen,
@@ -5347,7 +6062,9 @@ export default function App({
       sessions
         .filter(
           (session) =>
-            !session.inboxAsk && sameProjectPath(session.cwd, sidebarCwd),
+            !session.inboxAsk &&
+            !session.orchestrationLeadId &&
+            sameProjectPath(session.cwd, sidebarCwd),
         )
         .map((session) =>
           summaryFromSession(session, {
@@ -5983,410 +6700,421 @@ export default function App({
   };
 
   return (
-    <div
-      className={`flex h-full text-content ${
-        HAS_NATIVE_GLASS ? "bg-background-base/40" : "bg-background-base"
-      }`}
-    >
-      <Sidebar
-        cwd={sidebarCwd}
-        gitCwd={gitCwd}
-        open
-        tab={sidebarTab}
-        onTabChange={setSidebarTab}
-        filesSearchOpen={filesSearchOpen}
-        onFilesSearchOpenChange={setFilesSearchOpen}
-        onOpenFilesSearch={onFindInProject}
-        searchFocusToken={searchFocusToken}
-        sessions={sidebarHistory}
-        busySessionIds={busySessionIds}
-        approvalSessionIds={approvalSessionIds}
-        activeSessionId={active?.id}
-        status={historyFailed ? "error" : "idle"}
-        pending={historyPending}
-        onSelectSession={onSelectHistorySession}
-        onPrefetchSession={onPrefetchHistorySession}
-        onSessionNavigationOrder={onSessionNavigationOrder}
-        onPlaceSessionOnPane={onPlaceSessionOnPane}
-        onRenameSession={onRenameHistorySession}
-        onArchiveSession={onArchiveHistorySession}
-        onArchiveSessions={onArchiveHistorySessions}
-        onPinSession={onPinHistorySession}
-        onPinSessions={onPinHistorySessions}
-        reminders={sessionReminders.reminders}
-        onSetReminders={sessionReminders.schedule}
-        onCancelReminders={sessionReminders.cancel}
-        onDeleteSession={onDeleteHistorySession}
-        onDeleteSessions={onDeleteHistorySessions}
-        onOpenFile={onOpenFile}
-        onOpenTerminal={onOpenTerminal}
-        onFileMoved={onFileMoved}
-        onFileDeleted={onFileDeleted}
-        canGoBack={
-          tabVisitNav.canBack ||
-          searchViewOpen ||
-          settingsOpen ||
-          inboxViewOpen ||
-          notesViewOpen
-        }
-        canGoForward={tabVisitNav.canForward}
-        onGoBack={onRailBack}
-        onGoForward={onRailForward}
-        onOpenDiff={onOpenWorkingTreeDiff}
-        onOpenAllChanges={onOpenAllChanges}
-        onOpenCommit={onOpenCommit}
-        onShowSourceControl={onToggleChanges}
-        selectedDiffPath={
-          activeTab ? selectedChangePath(activeTab, gitCwd) : undefined
-        }
-        selectedDiffKind={activeTab ? selectedChangeKind(activeTab) : undefined}
-        selectedCommitSha={activeTab ? selectedCommitSha(activeTab) : undefined}
-        textHarness={pickTextHarness(active?.harness)}
-        recents={recents}
-        busyProjectPaths={sessions.flatMap((session) =>
-          session.busy && session.cwd ? [session.cwd] : [],
-        )}
-        liveAgents={liveAgents}
-        onSelectAgent={onSelectLiveAgent}
-        onSelectProject={onSelectProject}
-        onOpenProject={pickProject}
-        onRemoveProject={onRemoveProject}
-        onNew={onNew}
-        openSessions={openProjectSessions}
-        onNewTerminal={onNewTerminal}
-        onSearch={onOpenSearch}
-        onOpenInbox={onOpenInbox}
-        onOpenInboxItem={onOpenLinkedWorkItem}
-        onOpenNotes={notesEnabled ? onOpenNotes : undefined}
-        onGoToFile={onGoToFile}
-        searchActive={searchViewOpen}
-        inboxActive={inboxViewOpen}
-        notesActive={notesViewOpen}
-        notesEnabled={notesEnabled}
-        projectRailOpen={projectRailOpen}
-        onToggleProjectRail={onToggleProjectRail}
-        unseenFinishedIds={unseenFinishedIds}
-        inboxUnseen={inboxUnseen}
-        linkedSessionUpdateIds={linkedSessionUpdateIds}
-        settingsOpen={settingsOpen}
-        settingsSection={settingsSection}
-        onOpenSettings={onOpenSettings}
-        onSelectSettingsSection={onSelectSettingsSection}
-        onCloseSettings={onCloseSettings}
-        updateNotice={updateNotice}
-        onOpenWhatsNew={onOpenWhatsNew}
-        onDismissUpdate={() => setUpdateNotice(null)}
-      />
-
-      <div className="body-glass flex min-h-0 min-w-0 flex-1 flex-col">
+    <OrchestrationActions.Provider value={orchestrationActions}>
+      <OrchestrationWorkers.Provider value={orchestrationWorkers}>
         <div
-          className={
-            searchViewOpen || settingsOpen || inboxViewOpen || notesViewOpen
-              ? "hidden"
-              : "flex min-h-0 min-w-0 flex-1 flex-col"
-          }
-          aria-hidden={
-            searchViewOpen || settingsOpen || inboxViewOpen || notesViewOpen
-          }
-          inert={
-            searchViewOpen ||
-            settingsOpen ||
-            inboxViewOpen ||
-            notesViewOpen ||
-            undefined
-          }
+          className={`flex h-full text-content ${
+            HAS_NATIVE_GLASS ? "bg-background-base/40" : "bg-background-base"
+          }`}
         >
-          {!IS_MAC ? (
-            <MenuBar
-              onNew={onNew}
-              onNewTerminal={onNewTerminal}
-              onToggleTerminal={onToggleProjectTerminal}
-              onGoToFile={onGoToFile}
-              onToggleSidebar={onToggleSidebar}
-              onShowSourceControl={onToggleChanges}
-              onCloseCurrentTab={
-                activeTabId ? () => onCloseTab(activeTabId) : undefined
-              }
-              onCloseOtherTabs={onCloseOtherTabs}
-              onCloseAllTabs={onCloseAllTabs}
-              onPickProject={pickProject}
-              onFindInProject={onFindInProject}
-              onSearch={onOpenSearch}
-              onOpenInbox={onOpenInbox}
-              onOpenNotes={notesEnabled ? onOpenNotes : undefined}
-              onZoomIn={() => {
-                const next = saveUiScale(zoomInUiScale(loadUiScale()));
-                void applyUiScale(next);
-              }}
-              onZoomOut={() => {
-                const next = saveUiScale(zoomOutUiScale(loadUiScale()));
-                void applyUiScale(next);
-              }}
-              onZoomReset={() => {
-                saveUiScale(UI_SCALE_DEFAULT);
-                void applyUiScale(UI_SCALE_DEFAULT);
-              }}
-            />
-          ) : null}
-          <TitleBar
-            tabs={titleTabs}
-            activeId={activeTabId}
+          <Sidebar
             cwd={sidebarCwd}
-            projectRailOpen={projectRailOpen}
-            onToggleSidebar={onToggleSidebar}
-            onSelect={activateTab}
+            gitCwd={gitCwd}
+            open
+            tab={sidebarTab}
+            onTabChange={setSidebarTab}
+            filesSearchOpen={filesSearchOpen}
+            onFilesSearchOpenChange={setFilesSearchOpen}
+            onOpenFilesSearch={onFindInProject}
+            searchFocusToken={searchFocusToken}
+            sessions={sidebarHistory}
+            busySessionIds={busySessionIds}
+            approvalSessionIds={approvalSessionIds}
+            activeSessionId={active?.id}
+            status={historyFailed ? "error" : "idle"}
+            pending={historyPending}
+            onSelectSession={onSelectHistorySession}
+            onPrefetchSession={onPrefetchHistorySession}
+            onSessionNavigationOrder={onSessionNavigationOrder}
+            onPlaceSessionOnPane={onPlaceSessionOnPane}
+            onRenameSession={onRenameHistorySession}
+            onArchiveSession={onArchiveHistorySession}
+            onArchiveSessions={onArchiveHistorySessions}
+            onPinSession={onPinHistorySession}
+            onPinSessions={onPinHistorySessions}
+            reminders={sessionReminders.reminders}
+            onSetReminders={sessionReminders.schedule}
+            onCancelReminders={sessionReminders.cancel}
+            onDeleteSession={onDeleteHistorySession}
+            onDeleteSessions={onDeleteHistorySessions}
+            onOpenFile={onOpenFile}
+            onOpenTerminal={onOpenTerminal}
+            onFileMoved={onFileMoved}
+            onFileDeleted={onFileDeleted}
+            canGoBack={
+              tabVisitNav.canBack ||
+              searchViewOpen ||
+              settingsOpen ||
+              inboxViewOpen ||
+              notesViewOpen
+            }
+            canGoForward={tabVisitNav.canForward}
+            onGoBack={onRailBack}
+            onGoForward={onRailForward}
+            onOpenDiff={onOpenWorkingTreeDiff}
+            onOpenAllChanges={onOpenAllChanges}
+            onOpenCommit={onOpenCommit}
+            onShowSourceControl={onToggleChanges}
+            selectedDiffPath={
+              activeTab ? selectedChangePath(activeTab, gitCwd) : undefined
+            }
+            selectedDiffKind={
+              activeTab ? selectedChangeKind(activeTab) : undefined
+            }
+            selectedCommitSha={
+              activeTab ? selectedCommitSha(activeTab) : undefined
+            }
+            textHarness={pickTextHarness(active?.harness)}
+            recents={recents}
+            busyProjectPaths={sessions.flatMap((session) =>
+              session.busy && session.cwd ? [session.cwd] : [],
+            )}
+            liveAgents={liveAgents}
+            onSelectAgent={onSelectLiveAgent}
+            onSelectProject={onSelectProject}
+            onOpenProject={pickProject}
+            onRemoveProject={onRemoveProject}
             onNew={onNew}
+            openSessions={openProjectSessions}
             onNewTerminal={onNewTerminal}
-            onShowTerminal={onShowProjectTerminal}
-            projectTerminalActive={
-              !!currentProjectDock && currentProjectDock.pane.files.length > 0
-            }
-            onOpenSettings={onOpenSettings}
+            onSearch={onOpenSearch}
             onOpenInbox={onOpenInbox}
+            onOpenInboxItem={onOpenLinkedWorkItem}
             onOpenNotes={notesEnabled ? onOpenNotes : undefined}
-            onClose={onCloseTitleTab}
-            onCloseMany={onCloseTabs}
-            onReorder={onReorderTabs}
             onGoToFile={onGoToFile}
-            recents={recents}
-            onSelectProject={onSelectProject}
+            searchActive={searchViewOpen}
+            inboxActive={inboxViewOpen}
+            notesActive={notesViewOpen}
+            notesEnabled={notesEnabled}
+            projectRailOpen={projectRailOpen}
+            onToggleProjectRail={onToggleProjectRail}
+            unseenFinishedIds={unseenFinishedIds}
+            inboxUnseen={inboxUnseen}
+            linkedSessionUpdateIds={linkedSessionUpdateIds}
+            settingsOpen={settingsOpen}
+            settingsSection={settingsSection}
+            onOpenSettings={onOpenSettings}
+            onSelectSettingsSection={onSelectSettingsSection}
+            onCloseSettings={onCloseSettings}
+            updateNotice={updateNotice}
+            onOpenWhatsNew={onOpenWhatsNew}
+            onDismissUpdate={() => setUpdateNotice(null)}
           />
 
-          <main className="relative min-h-0 min-w-0 flex-1">
+          <div className="body-glass flex min-h-0 min-w-0 flex-1 flex-col">
             <div
-              ref={dockGridRef}
-              className="absolute inset-0 grid h-full min-h-0 min-w-0"
+              className={
+                searchViewOpen || settingsOpen || inboxViewOpen || notesViewOpen
+                  ? "hidden"
+                  : "flex min-h-0 min-w-0 flex-1 flex-col"
+              }
+              aria-hidden={
+                searchViewOpen || settingsOpen || inboxViewOpen || notesViewOpen
+              }
+              inert={
+                searchViewOpen ||
+                settingsOpen ||
+                inboxViewOpen ||
+                notesViewOpen ||
+                undefined
+              }
             >
-              {projectTerminals.map((dock) => {
-                const show =
-                  dock.open && sameProjectPath(dock.projectPath, projectCwd);
-                return (
-                  <div
-                    key={dock.projectPath}
-                    className={
-                      show
-                        ? "h-full min-h-0 min-w-0 w-full overflow-hidden"
-                        : "hidden"
-                    }
-                    style={show ? { gridArea: "dock" } : undefined}
-                    aria-hidden={!show}
-                  >
-                    <ProjectTerminalDock
-                      dock={dock}
-                      focused={show && projectTerminalFocused}
-                      onFocus={focusProjectTerminal}
-                      onHide={onHideProjectTerminal}
-                      onSideChange={onProjectTerminalSide}
-                      onSizePaint={paintDockSize}
-                      onSizeCommit={commitDockSize}
-                      onAddTerminal={() =>
-                        onOpenTerminal(active?.cwd ?? projectCwd)
-                      }
-                      onSelectTerminal={onSelectProjectTerminal}
-                      onCloseTerminal={onCloseProjectTerminal}
-                      onCloseOtherTerminals={onCloseOtherProjectTerminals}
-                      onReorderTerminals={onReorderProjectTerminals}
-                      onTerminalMetaChange={onTerminalMetaChange}
-                    />
-                  </div>
-                );
-              })}
-              <div
-                className="relative flex min-h-0 min-w-0 flex-row"
-                style={{ gridArea: "main" }}
-              >
-                <div className="relative min-h-0 min-w-0 flex-1">
-                  {tabs.map((tab) => (
-                    <div
-                      key={tab.id}
-                      aria-hidden={tab.id !== activeTabId}
-                      className={
-                        tab.id === activeTabId
-                          ? "absolute inset-0 flex h-full min-h-0 flex-col"
-                          : "hidden"
-                      }
-                    >
-                      <div className="flex h-full min-h-0 min-w-0 flex-1 flex-col">
-                        <PaneTree
-                          {...sessionPaneProps}
-                          visible={tab.id === activeTabId && !inboxViewOpen}
-                          layout={tab.layout}
-                          sessions={sessions}
-                          editorPanes={[
-                            ...tab.editorPanes,
-                            ...(tab.terminalPanes ?? []),
-                          ]}
-                          dirtyFileIds={dirtyFiles}
-                          fileErrorCounts={fileErrorCounts}
-                          focusedId={
-                            tab.id === activeTabId &&
-                            !inboxViewOpen &&
-                            !tab.diffFocused &&
-                            !projectTerminalFocused
-                              ? tab.focusedId
-                              : ""
-                          }
-                          addToChatSessionId={
-                            tab.id === activeTabId ? active?.id : undefined
-                          }
-                          composerFocused={
-                            composerFocused && !projectTerminalFocused
-                          }
-                          onSelectFile={onSelectFileSurface}
-                          onCloseFile={onCloseFile}
-                          onCloseOtherFiles={onCloseOtherFiles}
-                          onReorderFiles={onReorderFiles}
-                          onFileDirtyChange={onFileDirtyChange}
-                          onFileErrorCountChange={onFileErrorCountChange}
-                          onRatio={(splitId, index, ratio) =>
-                            onRatio(tab.id, splitId, index, ratio)
+              {!IS_MAC ? (
+                <MenuBar
+                  onNew={onNew}
+                  onNewTerminal={onNewTerminal}
+                  onToggleTerminal={onToggleProjectTerminal}
+                  onGoToFile={onGoToFile}
+                  onToggleSidebar={onToggleSidebar}
+                  onShowSourceControl={onToggleChanges}
+                  onCloseCurrentTab={
+                    activeTabId ? () => onCloseTab(activeTabId) : undefined
+                  }
+                  onCloseOtherTabs={onCloseOtherTabs}
+                  onCloseAllTabs={onCloseAllTabs}
+                  onPickProject={pickProject}
+                  onFindInProject={onFindInProject}
+                  onSearch={onOpenSearch}
+                  onOpenInbox={onOpenInbox}
+                  onOpenNotes={notesEnabled ? onOpenNotes : undefined}
+                  onZoomIn={() => {
+                    const next = saveUiScale(zoomInUiScale(loadUiScale()));
+                    void applyUiScale(next);
+                  }}
+                  onZoomOut={() => {
+                    const next = saveUiScale(zoomOutUiScale(loadUiScale()));
+                    void applyUiScale(next);
+                  }}
+                  onZoomReset={() => {
+                    saveUiScale(UI_SCALE_DEFAULT);
+                    void applyUiScale(UI_SCALE_DEFAULT);
+                  }}
+                />
+              ) : null}
+              <TitleBar
+                tabs={titleTabs}
+                activeId={activeTabId}
+                cwd={sidebarCwd}
+                projectRailOpen={projectRailOpen}
+                onToggleSidebar={onToggleSidebar}
+                onSelect={activateTab}
+                onNew={onNew}
+                onNewTerminal={onNewTerminal}
+                onShowTerminal={onShowProjectTerminal}
+                projectTerminalActive={
+                  !!currentProjectDock &&
+                  currentProjectDock.pane.files.length > 0
+                }
+                onOpenSettings={onOpenSettings}
+                onOpenInbox={onOpenInbox}
+                onOpenNotes={notesEnabled ? onOpenNotes : undefined}
+                onClose={onCloseTitleTab}
+                onCloseMany={onCloseTabs}
+                onReorder={onReorderTabs}
+                onGoToFile={onGoToFile}
+                recents={recents}
+                onSelectProject={onSelectProject}
+              />
+
+              <main className="relative min-h-0 min-w-0 flex-1">
+                <div
+                  ref={dockGridRef}
+                  className="absolute inset-0 grid h-full min-h-0 min-w-0"
+                >
+                  {projectTerminals.map((dock) => {
+                    const show =
+                      dock.open &&
+                      sameProjectPath(dock.projectPath, projectCwd);
+                    return (
+                      <div
+                        key={dock.projectPath}
+                        className={
+                          show
+                            ? "h-full min-h-0 min-w-0 w-full overflow-hidden"
+                            : "hidden"
+                        }
+                        style={show ? { gridArea: "dock" } : undefined}
+                        aria-hidden={!show}
+                      >
+                        <ProjectTerminalDock
+                          dock={dock}
+                          focused={show && projectTerminalFocused}
+                          onFocus={focusProjectTerminal}
+                          onHide={onHideProjectTerminal}
+                          onSideChange={onProjectTerminalSide}
+                          onSizePaint={paintDockSize}
+                          onSizeCommit={commitDockSize}
+                          onAddTerminal={() =>
+                            onOpenTerminal(active?.cwd ?? projectCwd)
                           }
-                          editorNavigation={editorNavigation}
-                          onUpdatePlan={onUpdatePlan}
-                          onMovePane={onMovePane}
+                          onSelectTerminal={onSelectProjectTerminal}
+                          onCloseTerminal={onCloseProjectTerminal}
+                          onCloseOtherTerminals={onCloseOtherProjectTerminals}
+                          onReorderTerminals={onReorderProjectTerminals}
                           onTerminalMetaChange={onTerminalMetaChange}
                         />
                       </div>
+                    );
+                  })}
+                  <div
+                    className="relative flex min-h-0 min-w-0 flex-row"
+                    style={{ gridArea: "main" }}
+                  >
+                    <div className="relative min-h-0 min-w-0 flex-1">
+                      {tabs.map((tab) => (
+                        <div
+                          key={tab.id}
+                          aria-hidden={tab.id !== activeTabId}
+                          className={
+                            tab.id === activeTabId
+                              ? "absolute inset-0 flex h-full min-h-0 flex-col"
+                              : "hidden"
+                          }
+                        >
+                          <div className="flex h-full min-h-0 min-w-0 flex-1 flex-col">
+                            <PaneTree
+                              {...sessionPaneProps}
+                              visible={tab.id === activeTabId && !inboxViewOpen}
+                              layout={tab.layout}
+                              sessions={sessions}
+                              editorPanes={[
+                                ...tab.editorPanes,
+                                ...(tab.terminalPanes ?? []),
+                              ]}
+                              dirtyFileIds={dirtyFiles}
+                              fileErrorCounts={fileErrorCounts}
+                              focusedId={
+                                tab.id === activeTabId &&
+                                !inboxViewOpen &&
+                                !tab.diffFocused &&
+                                !projectTerminalFocused
+                                  ? tab.focusedId
+                                  : ""
+                              }
+                              addToChatSessionId={
+                                tab.id === activeTabId ? active?.id : undefined
+                              }
+                              composerFocused={
+                                composerFocused && !projectTerminalFocused
+                              }
+                              onSelectFile={onSelectFileSurface}
+                              onCloseFile={onCloseFile}
+                              onCloseOtherFiles={onCloseOtherFiles}
+                              onReorderFiles={onReorderFiles}
+                              onFileDirtyChange={onFileDirtyChange}
+                              onFileErrorCountChange={onFileErrorCountChange}
+                              onRatio={(splitId, index, ratio) =>
+                                onRatio(tab.id, splitId, index, ratio)
+                              }
+                              editorNavigation={editorNavigation}
+                              onUpdatePlan={onUpdatePlan}
+                              onMovePane={onMovePane}
+                              onTerminalMetaChange={onTerminalMetaChange}
+                            />
+                          </div>
+                        </div>
+                      ))}
                     </div>
-                  ))}
+                  </div>
                 </div>
-              </div>
+              </main>
             </div>
-          </main>
-        </div>
-        {searchViewOpen ? (
-          <SearchView
-            open
-            cwd={sidebarCwd}
-            recents={recents}
-            history={projectHistory}
-            sessions={sessions.filter((session) => !session.inboxAsk)}
-            focusToken={searchViewFocusToken}
-            besideRail={projectRailOpen}
-            onClose={onLeaveSearch}
-            onToggleSidebar={onToggleSidebar}
-            onOpenFile={onOpenFile}
-            onOpenSession={onSelectHistorySession}
-            onOpenProject={onSelectProject}
-          />
-        ) : null}
-        <div className="hidden" aria-hidden>
-          {sessions
-            .filter((session) => session.inboxAsk)
-            .map((session) => {
-              const visible =
-                inboxViewOpen && inboxAskPortal?.sessionId === session.id;
-              return (
-                <SessionSurface
-                  key={session.id}
-                  host={visible ? inboxAskPortal.host : undefined}
-                >
-                  <SessionPane
-                    {...sessionPaneProps}
-                    session={session}
-                    visible={visible}
-                    focused={visible}
-                    inSplit={false}
-                    composerFocused={composerFocused}
-                  />
-                </SessionSurface>
-              );
-            })}
-        </div>
-        {inboxViewOpen ? (
-          <InboxView
-            cwd={sidebarCwd}
-            recents={recents}
-            besideRail={projectRailOpen}
-            onClose={onLeaveInbox}
-            onToggleSidebar={onToggleSidebar}
-            onStart={onStartInboxItem}
-            onAsk={onAskInboxItem}
-            onAskRestart={onRestartInboxAsk}
-            onAskMount={setInboxAskPortal}
-            sessions={inboxRelatedSessions}
-            onOpenSession={onOpenInboxSession}
-            target={inboxTarget}
-            onOpenIntegrations={onOpenInboxIntegrations}
-          />
-        ) : null}
-        {notesViewOpen ? (
-          <NotesView
-            besideRail={projectRailOpen}
-            cwd={projectCwd}
-            recents={recents}
-            onClose={onLeaveNotes}
-            onToggleSidebar={onToggleSidebar}
-          />
-        ) : null}
-        {settingsOpen ? (
-          <SettingsView
-            section={settingsSection}
-            anchor={settingsAnchor}
-            cwd={sidebarCwd}
-            sessions={sidebarHistory}
-            besideRail
-            onClose={onCloseSettings}
-            onOpenSession={onOpenArchivedSession}
-            onArchiveSession={onArchiveHistorySession}
-            onDeleteSession={onDeleteHistorySession}
-            onRestoreProject={onRestoreProject}
-            onDeleteProject={(path) =>
-              onRemoveProject(path, { purgeData: true })
+            {searchViewOpen ? (
+              <SearchView
+                open
+                cwd={sidebarCwd}
+                recents={recents}
+                history={projectHistory}
+                sessions={sessions.filter((session) => !session.inboxAsk)}
+                focusToken={searchViewFocusToken}
+                besideRail={projectRailOpen}
+                onClose={onLeaveSearch}
+                onToggleSidebar={onToggleSidebar}
+                onOpenFile={onOpenFile}
+                onOpenSession={onSelectHistorySession}
+                onOpenProject={onSelectProject}
+              />
+            ) : null}
+            <div className="hidden" aria-hidden>
+              {sessions
+                .filter((session) => session.inboxAsk)
+                .map((session) => {
+                  const visible =
+                    inboxViewOpen && inboxAskPortal?.sessionId === session.id;
+                  return (
+                    <SessionSurface
+                      key={session.id}
+                      host={visible ? inboxAskPortal.host : undefined}
+                    >
+                      <SessionPane
+                        {...sessionPaneProps}
+                        session={session}
+                        visible={visible}
+                        focused={visible}
+                        inSplit={false}
+                        composerFocused={composerFocused}
+                      />
+                    </SessionSurface>
+                  );
+                })}
+            </div>
+            {inboxViewOpen ? (
+              <InboxView
+                cwd={sidebarCwd}
+                recents={recents}
+                besideRail={projectRailOpen}
+                onClose={onLeaveInbox}
+                onToggleSidebar={onToggleSidebar}
+                onStart={onStartInboxItem}
+                onAsk={onAskInboxItem}
+                onAskRestart={onRestartInboxAsk}
+                onAskMount={setInboxAskPortal}
+                sessions={inboxRelatedSessions}
+                onOpenSession={onOpenInboxSession}
+                target={inboxTarget}
+                onOpenIntegrations={onOpenInboxIntegrations}
+              />
+            ) : null}
+            {notesViewOpen ? (
+              <NotesView
+                besideRail={projectRailOpen}
+                cwd={projectCwd}
+                recents={recents}
+                onClose={onLeaveNotes}
+                onToggleSidebar={onToggleSidebar}
+              />
+            ) : null}
+            {settingsOpen ? (
+              <SettingsView
+                section={settingsSection}
+                anchor={settingsAnchor}
+                cwd={sidebarCwd}
+                sessions={sidebarHistory}
+                besideRail
+                onClose={onCloseSettings}
+                onOpenSession={onOpenArchivedSession}
+                onArchiveSession={onArchiveHistorySession}
+                onDeleteSession={onDeleteHistorySession}
+                onRestoreProject={onRestoreProject}
+                onDeleteProject={(path) =>
+                  onRemoveProject(path, { purgeData: true })
+                }
+                onOpenWhatsNew={onOpenWhatsNew}
+              />
+            ) : null}
+            {searchViewOpen ||
+            inboxViewOpen ||
+            notesViewOpen ||
+            settingsOpen ? null : (
+              <UsageFooter
+                providers={usageProviders}
+                session={usageSession}
+                terminals={runningTerminals}
+                terminalOpen={runningTerminalOpen}
+                onToggleTerminal={onToggleRunningTerminal}
+              />
+            )}
+          </div>
+
+          {filePickerOpen ? (
+            <FilePicker
+              open
+              cwd={gitCwd}
+              openPaths={openFilePaths}
+              onOpenFile={onOpenFile}
+              onClose={() => setFilePickerOpen(false)}
+            />
+          ) : null}
+
+          <ApprovalToasts
+            notices={hiddenApprovalToasts}
+            topOffset={
+              12 + (reminderNoticesHeight ? reminderNoticesHeight + 8 : 0)
             }
-            onOpenWhatsNew={onOpenWhatsNew}
+            onFocusSession={onOpenApprovalSession}
+            onApproval={onApproval}
           />
-        ) : null}
-        {searchViewOpen ||
-        inboxViewOpen ||
-        notesViewOpen ||
-        settingsOpen ? null : (
-          <UsageFooter
-            providers={usageProviders}
-            session={usageSession}
-            terminals={runningTerminals}
-            terminalOpen={runningTerminalOpen}
-            onToggleTerminal={onToggleRunningTerminal}
+          <ReminderNotices
+            reminders={sessionReminders.due}
+            error={sessionReminders.error}
+            onOpen={sessionReminders.open}
+            onSnooze={sessionReminders.schedule}
+            onDismiss={sessionReminders.cancel}
+            onRetry={sessionReminders.refresh}
+            onOpenSettings={() => openSettings()}
+            onHeightChange={setReminderNoticesHeight}
           />
-        )}
-      </div>
-
-      {filePickerOpen ? (
-        <FilePicker
-          open
-          cwd={gitCwd}
-          openPaths={openFilePaths}
-          onOpenFile={onOpenFile}
-          onClose={() => setFilePickerOpen(false)}
-        />
-      ) : null}
-
-      <ApprovalToasts
-        notices={hiddenApprovalToasts}
-        topOffset={12 + (reminderNoticesHeight ? reminderNoticesHeight + 8 : 0)}
-        onFocusSession={onOpenApprovalSession}
-        onApproval={onApproval}
-      />
-      <ReminderNotices
-        reminders={sessionReminders.due}
-        error={sessionReminders.error}
-        onOpen={sessionReminders.open}
-        onSnooze={sessionReminders.schedule}
-        onDismiss={sessionReminders.cancel}
-        onRetry={sessionReminders.refresh}
-        onOpenSettings={() => openSettings()}
-        onHeightChange={setReminderNoticesHeight}
-      />
-      {whatsNewVersion ? (
-        <WhatsNewDialog
-          version={whatsNewVersion}
-          onClose={() => setWhatsNewVersion(null)}
-        />
-      ) : null}
-    </div>
+          {whatsNewVersion ? (
+            <WhatsNewDialog
+              version={whatsNewVersion}
+              onClose={() => setWhatsNewVersion(null)}
+            />
+          ) : null}
+        </div>
+      </OrchestrationWorkers.Provider>
+    </OrchestrationActions.Provider>
   );
 }
-
 function conversationTitle(session: Session): string {
   const title = sessionDisplayTitle(session.title, session.harness);
   return title === "New session" ? "" : title;
diff --git a/src/chrome/Composer.tsx b/src/chrome/Composer.tsx
index d2a0283a..4c811e75 100644
--- a/src/chrome/Composer.tsx
+++ b/src/chrome/Composer.tsx
@@ -9,6 +9,7 @@ import {
   Pencil,
   Play,
   Plus,
+  Share,
   Square,
   StickyNote,
   Trash2,
@@ -66,7 +67,7 @@ import type {
   MessageQueueStatus,
   QueuedMessage,
   RuntimeMode,
-  TurnIntent,
+  ComposerTurnOptions,
 } from "../lib/session";
 import { HARNESS_TITLE, harnessSupportsAttachments } from "../lib/session";
 import type {
@@ -181,7 +182,7 @@ type Props = {
   onSubmit: (
     text: string,
     attachments: Attachment[],
-    options?: { intent?: TurnIntent },
+    options?: ComposerTurnOptions,
   ) => void;
   onStop?: () => void;
   onCompactContext?: () => boolean;
@@ -467,6 +468,7 @@ export function Composer({
   const [fileDrag, setFileDrag] = useState(false);
   const [plusOpen, setPlusOpen] = useState(false);
   const [planSelected, setPlanSelected] = useState(false);
+  const [orchestrationSelected, setOrchestrationSelected] = useState(false);
   const [slash, setSlash] = useState<SlashToken | null>(null);
   const [skillActive, setSkillActive] = useState(0);
   const [creatingSkill, setCreatingSkill] = useState(false);
@@ -830,7 +832,10 @@ export function Composer({
       syncHasValue(next, attachmentsRef.current);
       setSlash(null);
       setCreatingSkill(false);
-      if (planCommand) setPlanSelected(true);
+      if (planCommand) {
+        setPlanSelected(true);
+        setOrchestrationSelected(false);
+      }
       el.focus();
     },
     [onPlaceInFolder, openSessionFolderPicker, syncHasValue],
@@ -1005,7 +1010,12 @@ export function Composer({
     const files = attachments;
     if (!text && files.length === 0 && !noteCard && !handoffCard) return;
     onSubmit(text, files, {
-      intent: planSelected || command.planning ? "plan" : "default",
+      intent:
+        planSelected || command.planning
+          ? "plan"
+          : orchestrationSelected
+            ? "orchestrate"
+            : "default",
     });
     if (!ref.current) return;
     ref.current.value = "";
@@ -1014,6 +1024,7 @@ export function Composer({
     onDraftChange?.("");
     setAttachments([]);
     setPlanSelected(false);
+    setOrchestrationSelected(false);
     setSessionFolderSelected(false);
     setSessionFolderOpen(false);
     setPlusOpen(false);
@@ -1443,9 +1454,9 @@ export function Composer({
                     <FilePlus className="mt-0.5 size-4 shrink-0" />
                     <span className="min-w-0">
                       <span className="block text-[13px]">Upload file</span>
-                      <span className="block text-[11px] leading-4 text-content/45">
+                      <span className="block truncate whitespace-nowrap text-[11px] leading-4 text-content/45">
                         {attachmentsSupported
-                          ? "Attach files or images to this message"
+                          ? "Attach files or images"
                           : `${HARNESS_TITLE[harness]} does not support attachments`}
                       </span>
                     </span>
@@ -1456,6 +1467,7 @@ export function Composer({
                     onMouseDown={(e) => e.preventDefault()}
                     onClick={() => {
                       setPlanSelected((selected) => !selected);
+                      setOrchestrationSelected(false);
                       setPlusOpen(false);
                       ref.current?.focus();
                     }}
@@ -1464,17 +1476,64 @@ export function Composer({
                     <AiIdea className="mt-0.5 size-4 shrink-0 text-yellow-300/80" />
                     <span className="min-w-0 flex-1">
                       <span className="block text-[13px]">Plan mode</span>
-                      <span className="block text-[11px] leading-4 text-content/45">
-                        Create a plan to review before building
+                      <span className="block truncate whitespace-nowrap text-[11px] leading-4 text-content/45">
+                        Review a plan before building
                       </span>
                     </span>
                     {planSelected ? (
                       <Check className="mt-0.5 size-3.5 shrink-0 text-accent" />
                     ) : null}
                   </button>
+                  {!hideTopBar && (
+                    <button
+                      type="button"
+                      aria-pressed={orchestrationSelected}
+                      onMouseDown={(event) => event.preventDefault()}
+                      onClick={() => {
+                        setOrchestrationSelected((selected) => !selected);
+                        setPlanSelected(false);
+                        setPlusOpen(false);
+                        ref.current?.focus();
+                      }}
+                      className="flex w-full items-start gap-2.5 rounded-lg px-2 py-2 text-left text-content hover:bg-content/10"
+                    >
+                      <Share className="mt-0.5 size-4 shrink-0 text-fuchsia-300/65" />
+                      <span className="min-w-0 flex-1">
+                        <span className="flex items-center gap-1.5">
+                          <span className="text-[13px]">Orchestrator</span>
+                          <span className="rounded-full bg-fuchsia-300/10 px-1.5 py-0.5 text-[9px] font-medium leading-none tracking-wide text-fuchsia-200/55 mb-px">
+                            v1
+                          </span>
+                        </span>
+                        <span className="block truncate whitespace-nowrap text-[11px] leading-4 text-content/45">
+                          Plan and coordinate agent work
+                        </span>
+                      </span>
+                      {orchestrationSelected && (
+                        <Check className="mt-0.5 size-3.5 shrink-0 text-fuchsia-300/80" />
+                      )}
+                    </button>
+                  )}
                 </Popover>
               ) : null}
             </div>
+            {orchestrationSelected && (
+              <button
+                type="button"
+                title="Turn off Orchestrator mode"
+                aria-label="Turn off Orchestrator mode"
+                onMouseDown={(event) => event.preventDefault()}
+                onClick={() => {
+                  setOrchestrationSelected(false);
+                  ref.current?.focus();
+                }}
+                className="flex h-6.5 shrink-0 items-center gap-1 rounded-md bg-fuchsia-400/10 px-1.5 text-[11px] text-fuchsia-200/80 hover:bg-fuchsia-400/15"
+              >
+                <Share className="size-3.5" />
+                Orchestrator
+                <X className="size-3" />
+              </button>
+            )}
             {planSelected ? (
               <button
                 type="button"
diff --git a/src/chrome/OrchestrationActions.ts b/src/chrome/OrchestrationActions.ts
new file mode 100644
index 00000000..05d6ee45
--- /dev/null
+++ b/src/chrome/OrchestrationActions.ts
@@ -0,0 +1,38 @@
+import { createContext } from "react";
+import type { OrchestrationProposal } from "../lib/orchestrationPlan";
+import type { HarnessId } from "../lib/session";
+
+export type OrchestrationWorkerDetail = {
+  sessionId: string;
+  leadId: string;
+  title: string;
+  harness: HarnessId;
+};
+
+/**
+ * The lead's sidebar card lists workers. Approvals still go to the lead, not
+ * to the user; `openDetails` is the one way to watch a worker's transcript.
+ */
+export const OrchestrationWorkers = createContext<{
+  selectedId: string | null;
+  inspect(sessionId: string | null): void;
+  /**
+   * Open this worker beside its lead, for when the card's model line is not
+   * enough. Absent wherever the card renders without a workspace behind it.
+   */
+  openDetails?(worker: OrchestrationWorkerDetail): void;
+}>({ selectedId: null, inspect: () => {} });
+
+// Shared by transcript cards in both ordinary and split session panes.
+export const OrchestrationActions = createContext<{
+  update(
+    leadId: string,
+    blockId: string,
+    proposal: OrchestrationProposal,
+  ): void;
+  confirm(leadId: string, blockId: string): Promise<void>;
+  retry(leadId: string, blockId: string): void;
+  open(sessionId: string): void;
+  /** Open every worker of a run as tabs beside the lead, not sidebar rows. */
+  openAgents?(workers: OrchestrationWorkerDetail[]): void;
+} | null>(null);
diff --git a/src/chrome/OrchestrationFlow.test.ts b/src/chrome/OrchestrationFlow.test.ts
new file mode 100644
index 00000000..f61e3863
--- /dev/null
+++ b/src/chrome/OrchestrationFlow.test.ts
@@ -0,0 +1,747 @@
+// @vitest-environment happy-dom
+import { act, createElement, useState } from "react";
+import { createRoot, type Root } from "react-dom/client";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+vi.mock("@tauri-apps/api/core", () => ({
+  invoke: vi.fn(async () => []),
+  isTauri: () => false,
+  convertFileSrc: (path: string) => path,
+}));
+vi.mock("@tauri-apps/api/event", () => ({ listen: async () => () => {} }));
+vi.mock("@tauri-apps/api/webview", () => ({
+  getCurrentWebview: () => ({ onDragDropEvent: async () => () => {} }),
+}));
+vi.mock("@tauri-apps/api/window", () => ({
+  getCurrentWindow: () => ({ onFocusChanged: async () => () => {} }),
+}));
+vi.mock("../lib/harness/availability", () => ({
+  getHarnessAvailabilitySnapshot: () => 0,
+  hasProbedHarnessAvailability: () => true,
+  isHarnessAvailable: () => true,
+  harnessUnavailableHint: () => "",
+  probeHarnessAvailability: async () => {},
+  subscribeHarnessAvailability: () => () => {},
+}));
+vi.mock("../lib/harness/registry", async (importOriginal) => ({
+  ...(await importOriginal<typeof import("../lib/harness/registry")>()),
+  refreshHarnessCatalogs: async () => {},
+  isLiveHarness: () => true,
+}));
+vi.mock("./ModelPicker", () => ({ ModelPicker: () => null }));
+vi.mock("./SessionReview", () => ({
+  SessionReview: ({ undoLocked }: { undoLocked: boolean }) =>
+    createElement("div", { "data-review-undo-locked": String(undoLocked) }),
+}));
+vi.mock("../lib/orchestration", async (importOriginal) => ({
+  ...(await importOriginal<typeof import("../lib/orchestration")>()),
+  orchestrator: {
+    subscribe: () => () => {},
+    snapshot: () => emptyRuns,
+    hydrate: async () => {},
+    waitingFor: () => undefined,
+  },
+}));
+
+import { Composer } from "./Composer";
+import { AgentTranscript } from "../surfaces/AgentTranscript";
+import { SessionPane } from "../surfaces/SessionPane";
+import {
+  OrchestrationActions,
+  OrchestrationWorkers,
+} from "./OrchestrationActions";
+import { newSession } from "../lib/session";
+import type { OrchestrationRun, OrchestrationTask } from "../lib/orchestration";
+import type { OrchestrationSummary } from "../lib/orchestrationSummary";
+import { OrchestrationSidebarAgents } from "./OrchestrationSidebarAgents";
+import {
+  modelsFor,
+  setHarnessModels,
+  resetHarnessModelOverlays,
+} from "../lib/models";
+import type { OrchestrationProposal } from "../lib/orchestrationPlan";
+import { invoke } from "@tauri-apps/api/core";
+
+const emptyRuns: OrchestrationRun[] = [];
+let container: HTMLDivElement;
+let root: Root;
+beforeEach(() => {
+  vi.stubGlobal("IS_REACT_ACT_ENVIRONMENT", true);
+  localStorage.clear();
+  setHarnessModels("codex", [
+    { id: "codex:one", harness: "codex", name: "Worker One" },
+    { id: "codex:two", harness: "codex", name: "Worker Two" },
+  ]);
+  container = document.createElement("div");
+  document.body.append(container);
+  root = createRoot(container);
+});
+afterEach(() => {
+  act(() => root.unmount());
+  container.remove();
+  resetHarnessModelOverlays();
+  vi.unstubAllGlobals();
+  vi.clearAllMocks();
+  emptyRuns.length = 0;
+});
+const button = (text: string) =>
+  [...document.querySelectorAll("button")].find((element) =>
+    element.textContent?.includes(text),
+  )!;
+async function click(element: Element) {
+  expect(element).toBeTruthy();
+  await act(async () => {
+    (element as HTMLElement).click();
+  });
+}
+async function press(element: Element, key: string) {
+  await act(async () => {
+    element.dispatchEvent(new KeyboardEvent("keydown", { key, bubbles: true }));
+  });
+}
+async function input(
+  element: HTMLInputElement | HTMLTextAreaElement,
+  value: string,
+) {
+  const prototype =
+    element instanceof HTMLTextAreaElement
+      ? HTMLTextAreaElement.prototype
+      : HTMLInputElement.prototype;
+  await act(async () => {
+    Object.getOwnPropertyDescriptor(prototype, "value")!.set!.call(
+      element,
+      value,
+    );
+    element.dispatchEvent(new Event("input", { bubbles: true }));
+  });
+}
+
+describe("orchestration composer and card", () => {
+  it("toggles a badge through the plus menu and submits without a team setup or execution", async () => {
+    const model = modelsFor("codex")[0];
+    const submit = vi.fn();
+    await act(async () =>
+      root.render(
+        createElement(Composer, {
+          focused: false,
+          harness: "codex",
+          model: model.id,
+          runtimeMode: "supervised",
+          cwd: "/repo",
+          executionCwd: "/repo",
+          sessionId: "lead",
+          initialDraft: "Build settings",
+          hideProjectPicker: true,
+          hideBranchPicker: true,
+          onFocus: () => {},
+          onCwdChange: () => {},
+          onModelChange: () => {},
+          onRuntimeModeChange: () => {},
+          onSubmit: submit,
+        }),
+      ),
+    );
+    await click(
+      document.querySelector(
+        'button[aria-label="Add files or choose a mode"]',
+      )!,
+    );
+    expect(button("Plan mode")).toBeTruthy();
+    await click(button("Orchestrator"));
+    expect(document.querySelector('[role="dialog"]')).toBeNull();
+    expect(
+      document.querySelector('[aria-label="Turn off Orchestrator mode"]'),
+    ).not.toBeNull();
+    await click(
+      document.querySelector('[aria-label="Turn off Orchestrator mode"]')!,
+    );
+    expect(
+      document.querySelector('[aria-label="Turn off Orchestrator mode"]'),
+    ).toBeNull();
+    await click(
+      document.querySelector(
+        'button[aria-label="Add files or choose a mode"]',
+      )!,
+    );
+    await click(button("Plan mode"));
+    expect(
+      document.querySelector('[title="Turn off Plan mode"]'),
+    ).not.toBeNull();
+    await click(
+      document.querySelector(
+        'button[aria-label="Add files or choose a mode"]',
+      )!,
+    );
+    await click(button("Orchestrator"));
+    expect(document.querySelector('[title="Turn off Plan mode"]')).toBeNull();
+    const textarea = container.querySelector("textarea")!;
+    await act(async () =>
+      textarea.dispatchEvent(
+        new KeyboardEvent("keydown", { key: "Enter", bubbles: true }),
+      ),
+    );
+    expect(submit).toHaveBeenCalledWith("Build settings", [], {
+      intent: "orchestrate",
+    });
+    expect(
+      document.querySelector('[aria-label="Turn off Orchestrator mode"]'),
+    ).toBeNull();
+    expect(
+      vi
+        .mocked(invoke)
+        .mock.calls.some(([command]) => command === "control_enable"),
+    ).toBe(false);
+  });
+  it("lets the user change an assignment's model and waits for explicit confirmation", async () => {
+    const choices = [
+      { harness: "codex" as const, model: "codex:one", name: "Worker One" },
+      { harness: "claude" as const, model: "claude:two", name: "Worker Two" },
+    ];
+    const initial: OrchestrationProposal = {
+      version: 1,
+      leadId: "lead",
+      cwd: "/repo",
+      request: "Build",
+      author: choices[0],
+      settings: { choices, maxWorkers: 2 },
+      status: "ready",
+      title: "Build settings",
+      summary: "Split UI and persistence",
+      tasks: [
+        {
+          id: "ui",
+          title: "Settings UI",
+          prompt: "Build the form",
+          harness: "codex",
+          model: "codex:one",
+          files: ["src/settings"],
+          dependsOn: [],
+        },
+      ],
+    };
+    const confirm = vi.fn(async (_proposal: OrchestrationProposal) => {});
+    function Card() {
+      const [proposal, setProposal] = useState(initial);
+      return createElement(
+        OrchestrationActions.Provider,
+        {
+          value: {
+            update: (_id, _block, edited) => setProposal(edited),
+            confirm: async () => confirm(proposal),
+            retry: () => {},
+            open: () => {},
+          },
+        },
+        createElement(AgentTranscript, {
+          blocks: [
+            {
+              id: "card",
+              role: "plan",
+              text: "Readable plan",
+              orchestration: proposal,
+            },
+          ],
+        }),
+      );
+    }
+    await act(async () => root.render(createElement(Card)));
+    expect(container.textContent).toContain("Settings UI");
+    expect(
+      container.querySelector("[data-orchestration-review]"),
+    ).not.toBeNull();
+    expect(container.textContent).not.toContain("Readable plan");
+    // The lead's summary stays out of the card; the task rows carry the plan.
+    expect(container.textContent).not.toContain("Split UI and persistence");
+    expect(confirm).not.toHaveBeenCalled();
+    await click(
+      document.querySelector('[aria-label="Model for Settings UI"]')!,
+    );
+    expect(document.activeElement).toBe(
+      document.querySelector('[aria-label="Search assignment models"]'),
+    );
+    // Marks the surface as a picker, which is what keeps the composer from
+    // pulling focus straight back out of the search field.
+    expect(
+      document
+        .querySelector('[aria-label="Search assignment models"]')
+        ?.closest("[data-model-picker]"),
+    ).not.toBeNull();
+    await input(
+      document.querySelector('[aria-label="Search assignment models"]')!,
+      "Claude",
+    );
+    expect(
+      document.querySelector("[data-popover-side]")?.textContent,
+    ).not.toContain("Worker One");
+    // Arrows walk the list from the search field and Enter takes the highlight.
+    await input(
+      document.querySelector('[aria-label="Search assignment models"]')!,
+      "Worker",
+    );
+    await press(
+      document.querySelector('[aria-label="Search assignment models"]')!,
+      "ArrowDown",
+    );
+    await press(
+      document.querySelector('[aria-label="Search assignment models"]')!,
+      "Enter",
+    );
+    expect(container.textContent).toContain("Worker Two");
+    // The pointer reaches the same rows.
+    await click(
+      document.querySelector('[aria-label="Model for Settings UI"]')!,
+    );
+    await click(
+      [...document.querySelectorAll('[role="option"]')].find((row) =>
+        row.textContent?.includes("Worker Two"),
+      )!,
+    );
+    expect(container.textContent).toContain("Worker Two");
+    expect(container.querySelector("textarea")).toBeNull();
+    await click(
+      document.querySelector('[aria-label="Details for Settings UI"]')!,
+    );
+    await input(
+      document.querySelector('[aria-label="Instructions for task 1"]')!,
+      "Build the accessible form and check keyboard navigation",
+    );
+    await click(
+      [
+        ...document.querySelectorAll('[aria-label="Parallel workers"] button'),
+      ].find((option) => option.textContent === "1")!,
+    );
+    expect(confirm).not.toHaveBeenCalled();
+    await click(button("Confirm & start"));
+    expect(confirm).toHaveBeenCalledWith(
+      expect.objectContaining({
+        settings: expect.objectContaining({ maxWorkers: 1 }),
+        tasks: [
+          expect.objectContaining({
+            harness: "claude",
+            model: "claude:two",
+            prompt: "Build the accessible form and check keyboard navigation",
+          }),
+        ],
+      }),
+    );
+  });
+  it("never offers confirmation for a proposal that is still being generated", async () => {
+    const proposal: OrchestrationProposal = {
+      version: 1,
+      leadId: "lead",
+      cwd: "/repo",
+      request: "Build",
+      author: { harness: "codex", model: "test", name: "Lead" },
+      settings: { choices: [], maxWorkers: 2 },
+      status: "planning",
+      title: "Planning",
+      summary: "",
+      tasks: [],
+    };
+    await act(async () =>
+      root.render(
+        createElement(AgentTranscript, {
+          busy: true,
+          blocks: [
+            {
+              id: "draft",
+              role: "plan",
+              text: "",
+              orchestration: proposal,
+            },
+          ],
+        }),
+      ),
+    );
+    expect(container.querySelector("[data-orchestration-review]")).toBeNull();
+    expect(container.textContent).not.toContain("Confirm & start");
+  });
+  it("opens worker panes from View agents instead of the sidebar", async () => {
+    const open = vi.fn();
+    const openAgents = vi.fn();
+    const task: OrchestrationTask = {
+      id: "engine",
+      sessionId: "worker-a",
+      title: "Audit engine",
+      harness: "codex",
+      model: "codex:two",
+      prompt: "Review the engine",
+      files: [],
+      scopes: [],
+      dependsOn: [],
+      status: "cancelled",
+      accepted: false,
+      delivered: false,
+      result: "",
+    };
+    emptyRuns.push({
+      version: 1,
+      leadId: "lead",
+      cwd: "/repo",
+      status: "stopped",
+      allowedHarnesses: ["codex", "cursor"],
+      proposalId: "card",
+      maxWorkers: 2,
+      cli: "monocode",
+      tasks: [
+        task,
+        {
+          ...task,
+          id: "ui",
+          sessionId: "worker-b",
+          title: "Audit UI",
+          harness: "cursor",
+          model: "cursor:composer-2.5",
+          status: "completed",
+        },
+      ],
+      continuations: 0,
+      requests: {},
+    });
+    await act(async () =>
+      root.render(
+        createElement(
+          OrchestrationActions.Provider,
+          {
+            value: {
+              update: () => {},
+              confirm: async () => {},
+              retry: () => {},
+              open,
+              openAgents,
+            },
+          },
+          createElement(AgentTranscript, {
+            blocks: [
+              {
+                id: "card",
+                role: "plan",
+                text: "",
+                orchestration: {
+                  version: 1,
+                  leadId: "lead",
+                  cwd: "/repo",
+                  request: "Review",
+                  author: {
+                    harness: "codex",
+                    model: "codex:one",
+                    name: "Lead",
+                  },
+                  settings: { choices: [], maxWorkers: 2 },
+                  status: "approved",
+                  title: "Review local-agent orchestration branch",
+                  summary: "",
+                  tasks: [
+                    {
+                      id: "engine",
+                      title: "Audit engine",
+                      prompt: "Review the engine",
+                      harness: "codex",
+                      model: "codex:two",
+                      files: [],
+                      dependsOn: [],
+                    },
+                    {
+                      id: "ui",
+                      title: "Audit UI",
+                      prompt: "Review the UI",
+                      harness: "cursor",
+                      model: "cursor:composer-2.5",
+                      files: [],
+                      dependsOn: [],
+                    },
+                  ],
+                },
+              },
+            ],
+          }),
+        ),
+      ),
+    );
+    await click(button("View agents"));
+    expect(open).not.toHaveBeenCalled();
+    expect(openAgents).toHaveBeenCalledWith([
+      {
+        sessionId: "worker-a",
+        leadId: "lead",
+        title: "Audit engine",
+        harness: "codex",
+      },
+      {
+        sessionId: "worker-b",
+        leadId: "lead",
+        title: "Audit UI",
+        harness: "cursor",
+      },
+    ]);
+  });
+  it("gives the lead's transcript and composer the whole pane", async () => {
+    const lead = {
+      ...newSession("codex", "/repo", "codex:one"),
+      id: "lead",
+      blocks: [
+        { id: "user", role: "user" as const, text: "Build the feature" },
+        {
+          id: "answer",
+          role: "assistant" as const,
+          text: "I am coordinating the work.",
+        },
+      ],
+    };
+    const task: OrchestrationTask = {
+      id: "task",
+      sessionId: "worker",
+      title: "UI worker",
+      harness: "codex",
+      model: "codex:two",
+      prompt: "Build UI",
+      files: ["ui"],
+      scopes: ["/repo/ui"],
+      dependsOn: [],
+      status: "running",
+      accepted: false,
+      delivered: false,
+      result: "",
+    };
+    emptyRuns.push({
+      version: 1,
+      leadId: lead.id,
+      cwd: lead.cwd,
+      status: "active",
+      allowedHarnesses: ["codex"],
+      maxWorkers: 2,
+      cli: "monocode",
+      tasks: [
+        task,
+        {
+          ...task,
+          id: "second-task",
+          sessionId: "second",
+          title: "Check worker",
+        },
+      ],
+      continuations: 0,
+      requests: {},
+    });
+    const submit = vi.fn();
+    const approve = vi.fn();
+    const reply = vi.fn();
+    const open = vi.fn();
+    const noop = () => {};
+    function LeadPane({ id = lead.id, undoLocked = false } = {}) {
+      const [selectedId, inspect] = useState<string | null>(null);
+      return createElement(
+        OrchestrationActions.Provider,
+        { value: { update: noop, confirm: async () => {}, retry: noop, open } },
+        createElement(
+          OrchestrationWorkers.Provider,
+          { value: { selectedId, inspect } },
+          createElement(SessionPane, {
+            session: { ...lead, id },
+            reviewUndoLocked: undoLocked,
+            visible: true,
+            focused: true,
+            inSplit: false,
+            composerFocused: true,
+            recents: [],
+            onFocus: noop,
+            onClose: noop,
+            onCwdChange: noop,
+            onBranchChange: noop,
+            onModelChange: noop,
+            onModelSettingsChange: noop,
+            onRuntimeModeChange: noop,
+            onSubmit: submit,
+            onStop: noop,
+            onCompactContext: () => false,
+            onPlaceSessionInFolder: noop,
+            onDeleteQueuedMessage: noop,
+            onEditQueuedMessage: noop,
+            onQueuedMessageEditingChange: noop,
+            onSteerQueuedMessage: noop,
+            onResumeQueue: noop,
+            onApproval: approve,
+            onQuestionReply: reply,
+            onOpenFile: noop,
+            onOpenDiff: noop,
+            onOpenPlan: noop,
+            onBuildPlan: noop,
+            onNewTerminal: noop,
+          }),
+        ),
+      );
+    }
+    await act(async () => root.render(createElement(LeadPane)));
+    // Agents live on the sidebar card now; nothing narrows the lead's pane.
+    expect(container.querySelector("[data-orchestration-agents]")).toBeNull();
+    expect(container.textContent).toContain("I am coordinating the work.");
+    expect(container.textContent).not.toContain("UI worker");
+    expect(open).not.toHaveBeenCalled();
+    const composer = container.querySelector("textarea")!;
+    await input(composer, "Ask the UI worker to check keyboard navigation.");
+    await act(async () => {
+      composer.dispatchEvent(
+        new KeyboardEvent("keydown", { key: "Enter", bubbles: true }),
+      );
+    });
+    expect(submit).toHaveBeenCalledWith(
+      "lead",
+      "Ask the UI worker to check keyboard navigation.",
+      [],
+      { intent: "default" },
+    );
+    for (const status of ["active", "paused", "finished", "stopped"] as const) {
+      emptyRuns[0] = { ...emptyRuns[0], status };
+      for (const id of ["lead", "worker", "unrelated"]) {
+        await act(async () => root.render(createElement(LeadPane, { id })));
+        expect(
+          container
+            .querySelector("[data-review-undo-locked]")
+            ?.getAttribute("data-review-undo-locked"),
+        ).toBe(
+          String(
+            id !== "unrelated" && (status === "active" || status === "paused"),
+          ),
+        );
+      }
+    }
+    await act(async () =>
+      root.render(createElement(LeadPane, { undoLocked: true })),
+    );
+    expect(
+      container
+        .querySelector("[data-review-undo-locked]")
+        ?.getAttribute("data-review-undo-locked"),
+    ).toBe("true");
+  });
+
+  it("shows a blocked agent as the lead's to answer, not the user's", async () => {
+    const summary: OrchestrationSummary = {
+      status: "active",
+      live: true,
+      tasks: [
+        {
+          sessionId: "worker",
+          title: "UI worker",
+          harness: "codex",
+          model: "codex:two",
+          status: "running",
+          needsInput: true,
+        },
+        {
+          sessionId: "second",
+          title: "Check worker",
+          harness: "codex",
+          model: "codex:two",
+          status: "running",
+          needsInput: true,
+        },
+      ],
+    };
+    function Card() {
+      const [selectedId, inspect] = useState<string | null>(null);
+      return createElement(
+        OrchestrationWorkers.Provider,
+        { value: { selectedId, inspect } },
+        createElement(OrchestrationSidebarAgents, { leadId: "lead", summary }),
+      );
+    }
+    await act(async () => root.render(createElement(Card)));
+    expect(container.textContent).toContain("UI worker");
+    // A blocked agent expands itself so its model is visible, but the
+    // approval still belongs to the lead, not to this card.
+    expect(
+      container.querySelector(
+        '[data-orchestration-agent="worker"] [aria-expanded="true"]',
+      ),
+    ).not.toBeNull();
+    expect(container.textContent).toContain("Worker Two");
+    expect(button("Allow")).toBeUndefined();
+    expect(button("Deny")).toBeUndefined();
+    expect(container.textContent).not.toContain("Which check should I run?");
+  });
+
+  it("inspects an agent without taking the card's click or its tab", async () => {
+    const summary: OrchestrationSummary = {
+      status: "active",
+      live: true,
+      tasks: [
+        {
+          sessionId: "worker",
+          title: "UI worker",
+          harness: "codex",
+          model: "codex:two",
+          status: "running",
+        },
+      ],
+    };
+    const selectCard = vi.fn();
+    const openDetails = vi.fn();
+    function Card() {
+      const [selectedId, inspect] = useState<string | null>(null);
+      return createElement(
+        "div",
+        { onClick: selectCard },
+        createElement(
+          OrchestrationWorkers.Provider,
+          { value: { selectedId, inspect, openDetails } },
+          createElement(OrchestrationSidebarAgents, {
+            leadId: "lead",
+            summary,
+          }),
+        ),
+      );
+    }
+    await act(async () => root.render(createElement(Card)));
+    await click(
+      container.querySelector('[aria-label="Agent details: UI worker"]')!,
+    );
+    // Expanding a row is not a request to open the lead's tab.
+    expect(selectCard).not.toHaveBeenCalled();
+    await click(button("See details"));
+    expect(openDetails).toHaveBeenCalledWith({
+      sessionId: "worker",
+      leadId: "lead",
+      title: "UI worker",
+      harness: "codex",
+    });
+    expect(selectCard).not.toHaveBeenCalled();
+  });
+
+  it("expands any number of agents at once", async () => {
+    const summary: OrchestrationSummary = {
+      status: "active",
+      live: true,
+      tasks: ["one", "two", "three"].map((id) => ({
+        sessionId: id,
+        title: `Agent ${id}`,
+        harness: "codex" as const,
+        model: "codex:two",
+        status: "running" as const,
+      })),
+    };
+    function Card() {
+      const [selectedId, inspect] = useState<string | null>(null);
+      return createElement(
+        OrchestrationWorkers.Provider,
+        { value: { selectedId, inspect } },
+        createElement(OrchestrationSidebarAgents, { leadId: "lead", summary }),
+      );
+    }
+    await act(async () => root.render(createElement(Card)));
+    const row = (id: string) =>
+      container.querySelector<HTMLElement>(
+        `[data-orchestration-agent="${id}"] button`,
+      )!;
+    const openIds = () =>
+      [...container.querySelectorAll("[data-orchestration-agent]")]
+        .filter((entry) => entry.querySelector("[aria-expanded=true]"))
+        .map((entry) => entry.getAttribute("data-orchestration-agent"));
+    await click(row("one"));
+    await click(row("three"));
+    expect(openIds()).toEqual(["one", "three"]);
+    // Collapsing one leaves the other where it was.
+    await click(row("one"));
+    expect(openIds()).toEqual(["three"]);
+  });
+});
diff --git a/src/chrome/OrchestrationPreview.tsx b/src/chrome/OrchestrationPreview.tsx
new file mode 100644
index 00000000..ebd5ae3a
--- /dev/null
+++ b/src/chrome/OrchestrationPreview.tsx
@@ -0,0 +1,610 @@
+import {
+  useContext,
+  useEffect,
+  useLayoutEffect,
+  useRef,
+  useState,
+  useSyncExternalStore,
+  type KeyboardEvent as ReactKeyboardEvent,
+} from "react";
+import { HARNESS_TITLE, type Block } from "../lib/session";
+import type {
+  OrchestrationChoice,
+  ProposedTask,
+} from "../lib/orchestrationPlan";
+import { orchestrator } from "../lib/orchestration";
+import { resizeComposer } from "../lib/composerResize";
+import { useLockOverscroll } from "../hooks/useLockOverscroll";
+import { OrchestrationActions } from "./OrchestrationActions";
+import { HarnessIcon } from "./HarnessIcon";
+import { Popover } from "./Popover";
+import {
+  Check,
+  ChevronDown,
+  ChevronRight,
+  CircleDashed,
+  CircleHelp,
+  MessageMultiple,
+  Play,
+  Search,
+} from "./icons";
+
+function AssignmentModel({
+  task,
+  choices,
+  onChange,
+}: {
+  task: ProposedTask;
+  choices: OrchestrationChoice[];
+  onChange(choice: OrchestrationChoice): void;
+}) {
+  const [open, setOpen] = useState(false);
+  const [query, setQuery] = useState("");
+  const [active, setActive] = useState(0);
+  const anchor = useRef<HTMLButtonElement>(null);
+  const search = useRef<HTMLInputElement>(null);
+  const activeRef = useRef<HTMLButtonElement>(null);
+  const listOverscroll = useLockOverscroll<HTMLDivElement>();
+  const selected = choices.find(
+    (choice) => choice.harness === task.harness && choice.model === task.model,
+  );
+  const matches = choices.filter((choice) =>
+    `${choice.name} ${choice.model} ${HARNESS_TITLE[choice.harness]}`
+      .toLowerCase()
+      .includes(query.trim().toLowerCase()),
+  );
+  // Two things fought this field for focus. The composer takes focus back
+  // unless a picker surface is in the DOM, which `data-model-picker` below
+  // now declares; and the popover measures itself with `visibility: hidden`
+  // on its first pass, where nothing can be focused. Placement flushes in a
+  // layout effect ahead of this one, so focus now for the pass that is
+  // already on screen and again next frame, once placement has landed.
+  // Re-focusing a focused field is a no-op.
+  useEffect(() => {
+    if (!open) return;
+    search.current?.focus({ preventScroll: true });
+    const frame = requestAnimationFrame(() =>
+      search.current?.focus({ preventScroll: true }),
+    );
+    return () => cancelAnimationFrame(frame);
+  }, [open]);
+  useEffect(() => {
+    activeRef.current?.scrollIntoView({ block: "nearest" });
+  }, [active]);
+  const pick = (choice: OrchestrationChoice) => {
+    onChange(choice);
+    setOpen(false);
+    anchor.current?.focus();
+  };
+  // Arrows walk the list from the search field, the way the app's other
+  // pickers work. The keys stop here so the transcript underneath does not
+  // scroll along with the highlight.
+  const onSearchKey = (event: ReactKeyboardEvent<HTMLInputElement>) => {
+    if (event.key === "ArrowDown" || event.key === "ArrowUp") {
+      event.preventDefault();
+      event.stopPropagation();
+      if (!matches.length) return;
+      const step = event.key === "ArrowDown" ? 1 : -1;
+      setActive((index) =>
+        Math.min(matches.length - 1, Math.max(0, index + step)),
+      );
+      return;
+    }
+    if (event.key === "Enter") {
+      event.preventDefault();
+      event.stopPropagation();
+      const choice = matches[active];
+      if (choice) pick(choice);
+    }
+  };
+  return (
+    <div className="relative min-w-0">
+      <button
+        type="button"
+        ref={anchor}
+        aria-label={`Model for ${task.title}`}
+        aria-expanded={open}
+        onClick={() => {
+          setQuery("");
+          setActive(selected ? choices.indexOf(selected) : 0);
+          setOpen(!open);
+        }}
+        className="flex h-7 max-w-full items-center gap-1.5 rounded-md bg-content/5 px-2 text-[11px] text-content/60 hover:bg-content/10 hover:text-content"
+      >
+        <HarnessIcon harness={task.harness} className="size-3.5 shrink-0" />
+        <span className="truncate">
+          {selected?.name ?? task.model} · {HARNESS_TITLE[task.harness]}
+        </span>
+        <ChevronDown className="size-3 shrink-0" />
+      </button>
+      {open && (
+        <Popover
+          anchor={anchor}
+          side="bottom"
+          align="start"
+          width={260}
+          maxHeight={320}
+          onDismiss={() => setOpen(false)}
+          data-model-picker
+          className="flex flex-col overflow-hidden"
+        >
+          <label className="flex shrink-0 items-center gap-2 border-b border-content/10 px-3 py-2.5 text-content/50">
+            <Search className="size-3.5 shrink-0" strokeWidth={1.75} />
+            <input
+              ref={search}
+              type="text"
+              aria-label="Search assignment models"
+              placeholder="Search models or harnesses…"
+              spellCheck={false}
+              autoComplete="off"
+              value={query}
+              onChange={(event) => {
+                setQuery(event.target.value);
+                setActive(0);
+              }}
+              onKeyDown={onSearchKey}
+              className="min-w-0 flex-1 bg-transparent text-[13px] text-content outline-none placeholder:text-content/40"
+            />
+          </label>
+          <div
+            ref={listOverscroll}
+            role="listbox"
+            aria-label="Assignment models"
+            className="min-h-0 flex-1 overflow-y-auto overscroll-none p-1"
+          >
+            {matches.map((choice, index) => (
+              <button
+                key={`${choice.harness}:${choice.model}`}
+                ref={index === active ? activeRef : undefined}
+                type="button"
+                role="option"
+                aria-selected={choice === selected}
+                onMouseDown={(event) => event.preventDefault()}
+                onMouseEnter={() => setActive(index)}
+                onClick={() => pick(choice)}
+                className={`flex w-full items-center gap-2 rounded-md px-2 py-1.5 text-left ${
+                  index === active ? "bg-content/10" : ""
+                }`}
+              >
+                <HarnessIcon
+                  harness={choice.harness}
+                  className="size-4 shrink-0"
+                />
+                <span className="min-w-0 flex-1">
+                  <span className="block truncate text-[13px] leading-tight text-content">
+                    {choice.name}
+                  </span>
+                  <span className="mt-0.5 block truncate text-[11px] leading-tight text-content/45">
+                    {HARNESS_TITLE[choice.harness]}
+                  </span>
+                </span>
+                {choice === selected && (
+                  <Check
+                    className="size-3.5 shrink-0 text-content/55"
+                    strokeWidth={2}
+                  />
+                )}
+              </button>
+            ))}
+            {!matches.length && (
+              <p className="px-2 py-3 text-[12px] text-content/45">
+                No matching models
+              </p>
+            )}
+          </div>
+        </Popover>
+      )}
+    </div>
+  );
+}
+
+function WorkerHelp() {
+  const [hovered, setHovered] = useState(false);
+  const [open, setOpen] = useState(false);
+  const anchor = useRef<HTMLButtonElement>(null);
+  return (
+    <>
+      <button
+        type="button"
+        ref={anchor}
+        aria-label="What parallel workers means"
+        aria-expanded={open}
+        onClick={() => setOpen((value) => !value)}
+        onMouseEnter={() => setHovered(true)}
+        onMouseLeave={() => setHovered(false)}
+        onFocus={() => setHovered(true)}
+        onBlur={() => setHovered(false)}
+        className="grid size-4 shrink-0 place-items-center rounded-full text-content/35 hover:text-content/70"
+      >
+        <CircleHelp className="size-3.5" strokeWidth={1.75} />
+      </button>
+      {(hovered || open) && (
+        <Popover
+          anchor={anchor}
+          side="top"
+          align="start"
+          width={250}
+          onDismiss={() => setOpen(false)}
+          className={`px-2.5 py-2 ${open ? "" : "pointer-events-none"}`}
+        >
+          <div className="text-[12px] leading-4 text-content">
+            How many workers run at once
+          </div>
+          <div className="mt-1 text-[11px] leading-4 text-content/50">
+            The rest of the tasks wait their turn, and a task that depends on
+            another waits for it either way. Every worker edits this same
+            project folder, so a lower number means fewer changes landing in it
+            at the same time.
+          </div>
+        </Popover>
+      )}
+    </>
+  );
+}
+
+function InstructionsField({
+  label,
+  value,
+  className,
+  onChange,
+}: {
+  label: string;
+  value: string;
+  className: string;
+  onChange(value: string): void;
+}) {
+  const ref = useRef<HTMLTextAreaElement>(null);
+  const lockOverscroll = useLockOverscroll<HTMLTextAreaElement>();
+  // The same growth the composer uses: fit the text, stop at `max-h-40` and
+  // scroll from there. The value is controlled, so one layout effect covers
+  // typing and edits that arrive from the lead alike.
+  useLayoutEffect(() => {
+    if (ref.current) resizeComposer(ref.current);
+  }, [value]);
+  return (
+    <textarea
+      ref={(el) => {
+        ref.current = el;
+        lockOverscroll(el);
+      }}
+      rows={1}
+      aria-label={label}
+      className={`${className} max-h-40 resize-none overscroll-none`}
+      value={value}
+      onChange={(event) => onChange(event.target.value)}
+    />
+  );
+}
+
+export function OrchestrationPreview({
+  block,
+  busy,
+}: {
+  block: Block;
+  busy?: boolean;
+}) {
+  const actions = useContext(OrchestrationActions);
+  const runs = useSyncExternalStore(
+    orchestrator.subscribe,
+    orchestrator.snapshot,
+    orchestrator.snapshot,
+  );
+  const proposal = block.orchestration!;
+  const run = runs.find(
+    (entry) =>
+      entry.leadId === proposal.leadId && entry.proposalId === block.id,
+  );
+  const [pending, setPending] = useState(false);
+  const [error, setError] = useState<string>();
+  const [expanded, setExpanded] = useState<string[]>([]);
+  const [showAll, setShowAll] = useState(false);
+  useEffect(() => {
+    if (actions)
+      void orchestrator
+        .hydrate(proposal.leadId)
+        .catch((reason: unknown) => setError(String(reason)));
+  }, [actions, proposal.leadId]);
+  const editable =
+    proposal.status === "ready" && !run && !pending && !busy && !!actions;
+  const planning = proposal.status === "planning";
+  const starting = pending || proposal.status === "starting";
+  const visible = showAll ? proposal.tasks : proposal.tasks.slice(0, 3);
+  const perform = async (fn: () => Promise<void>) => {
+    setPending(true);
+    setError(undefined);
+    try {
+      await fn();
+    } catch (reason) {
+      setError(reason instanceof Error ? reason.message : String(reason));
+    } finally {
+      setPending(false);
+    }
+  };
+  const change = (id: string, patch: Partial<ProposedTask>) => {
+    setError(undefined);
+    actions?.update(proposal.leadId, block.id, {
+      ...proposal,
+      tasks: proposal.tasks.map((task) =>
+        task.id === id ? { ...task, ...patch } : task,
+      ),
+    });
+  };
+  const secondary =
+    "flex h-7 items-center gap-1.5 rounded-md px-2.5 text-[11px] text-content/50 hover:bg-content/8 hover:text-content disabled:opacity-35";
+  const field =
+    "w-full rounded-md border border-content/12 bg-background-base/40 px-2 py-1.5 text-[12px] leading-5 text-content outline-none placeholder:text-content/35 focus:border-content/30";
+  const fieldLabel = "mb-1 block text-[11px] leading-tight text-content/45";
+  return (
+    <div
+      className="mb-2 overflow-hidden rounded-xl border border-content/10 bg-content/3 font-sans"
+      aria-label="Orchestration proposal"
+      data-orchestration-review
+    >
+      <div className="flex min-w-0 flex-wrap items-center gap-2.5 px-3 py-2.5">
+        <span className="grid size-8 shrink-0 place-items-center rounded-lg bg-content/8 text-content/55">
+          {planning || proposal.status === "starting" ? (
+            <CircleDashed className="size-4 animate-spin" />
+          ) : (
+            <MessageMultiple className="size-4" strokeWidth={1.75} />
+          )}
+        </span>
+        <div className="min-w-0 flex-1">
+          <div className="truncate text-[13px] font-medium leading-tight text-content/90">
+            {planning ? "Planning assignments…" : proposal.title}
+          </div>
+          <div className="mt-1 flex items-center gap-1.5 text-[11px] leading-tight text-content/45">
+            <HarnessIcon
+              harness={proposal.author.harness}
+              className="size-3 shrink-0"
+            />
+            <span
+              className="truncate"
+              title={HARNESS_TITLE[proposal.author.harness]}
+            >
+              Lead · {proposal.author.name}
+            </span>
+            {!!proposal.tasks.length && (
+              <span className="shrink-0">
+                · {proposal.tasks.length}{" "}
+                {proposal.tasks.length === 1 ? "task" : "tasks"}
+              </span>
+            )}
+          </div>
+        </div>
+        <div className="ml-auto flex shrink-0 items-center gap-0.5">
+          {!run && proposal.status === "invalid" && (
+            <button
+              className={secondary}
+              disabled={busy || !actions}
+              onClick={() => actions?.retry(proposal.leadId, block.id)}
+            >
+              Try again
+            </button>
+          )}
+          {!run && ["ready", "starting"].includes(proposal.status) && (
+            <button
+              className="flex h-7 items-center gap-1.5 rounded-md bg-content px-2.5 text-[11px] font-medium text-background-base hover:bg-content/80 disabled:opacity-40"
+              disabled={!editable}
+              onClick={() =>
+                void perform(() => actions!.confirm(proposal.leadId, block.id))
+              }
+            >
+              <Play className="size-3" strokeWidth={1.75} />
+              {starting ? "Starting…" : "Confirm & start"}
+            </button>
+          )}
+          {run && (
+            <button
+              className={secondary}
+              onClick={() =>
+                actions?.openAgents?.(
+                  run.tasks.map((task) => ({
+                    sessionId: task.sessionId,
+                    leadId: run.leadId,
+                    title: task.title,
+                    harness: task.harness,
+                  })),
+                )
+              }
+            >
+              View agents
+            </button>
+          )}
+        </div>
+      </div>
+      {planning && (
+        <p className="px-3 pb-2.5 text-[12px] leading-5 text-content/50">
+          {proposal.settings.choices.length
+            ? "Your lead is choosing tasks and worker models. Review the assignments here before starting."
+            : "Checking available harnesses and models…"}
+        </p>
+      )}
+      {!!proposal.tasks.length && (
+        <ul className="border-t border-content/10 py-1">
+          {visible.map((task) => {
+            const index = proposal.tasks.indexOf(task);
+            const open = expanded.includes(task.id);
+            return (
+              <li key={task.id}>
+                <div className="flex min-h-9 min-w-0 flex-wrap items-center gap-x-2 gap-y-1 px-3 py-1 hover:bg-content/5">
+                  <button
+                    type="button"
+                    aria-label={`Details for ${task.title}`}
+                    aria-expanded={open}
+                    onClick={() =>
+                      setExpanded((prev) =>
+                        open
+                          ? prev.filter((id) => id !== task.id)
+                          : [...prev, task.id],
+                      )
+                    }
+                    className="flex min-w-0 flex-1 items-center gap-2 py-1 text-left text-content/65 hover:text-content"
+                  >
+                    {open ? (
+                      <ChevronDown className="size-3.5 shrink-0" />
+                    ) : (
+                      <ChevronRight className="size-3.5 shrink-0" />
+                    )}
+                    <span className="truncate text-[12px]" title={task.title}>
+                      {task.title}
+                    </span>
+                  </button>
+                  <div className="max-w-[60%] min-w-0">
+                    {editable ? (
+                      <AssignmentModel
+                        task={task}
+                        choices={proposal.settings.choices}
+                        onChange={(choice) =>
+                          change(task.id, {
+                            harness: choice.harness,
+                            model: choice.model,
+                          })
+                        }
+                      />
+                    ) : (
+                      <span
+                        className="flex min-w-0 items-center gap-1.5 text-[11px] text-content/50"
+                        title={HARNESS_TITLE[task.harness]}
+                      >
+                        <HarnessIcon
+                          harness={task.harness}
+                          className="size-3 shrink-0"
+                        />
+                        <span className="truncate">
+                          {proposal.settings.choices.find(
+                            (choice) =>
+                              choice.harness === task.harness &&
+                              choice.model === task.model,
+                          )?.name ?? task.model}
+                        </span>
+                      </span>
+                    )}
+                  </div>
+                </div>
+                {open && (
+                  <div className="space-y-2.5 px-3 pb-3 pl-8 text-[11px] leading-4 text-content/45">
+                    {editable ? (
+                      <>
+                        <label className="block">
+                          <span className={fieldLabel}>Task</span>
+                          <input
+                            aria-label={`Title for task ${index + 1}`}
+                            className={field}
+                            value={task.title}
+                            onChange={(event) =>
+                              change(task.id, { title: event.target.value })
+                            }
+                          />
+                        </label>
+                        <label className="block">
+                          <span className={fieldLabel}>Instructions</span>
+                          <InstructionsField
+                            label={`Instructions for task ${index + 1}`}
+                            value={task.prompt}
+                            className={field}
+                            onChange={(prompt) => change(task.id, { prompt })}
+                          />
+                        </label>
+                      </>
+                    ) : (
+                      <p className="whitespace-pre-wrap text-[12px] leading-5 text-content/60">
+                        {task.prompt}
+                      </p>
+                    )}
+                    {!!task.dependsOn.length && (
+                      <p>
+                        After ·{" "}
+                        {task.dependsOn
+                          .map(
+                            (id) =>
+                              proposal.tasks.find((entry) => entry.id === id)
+                                ?.title ?? id,
+                          )
+                          .join(", ")}
+                      </p>
+                    )}
+                  </div>
+                )}
+              </li>
+            );
+          })}
+        </ul>
+      )}
+      {proposal.tasks.length > 3 && (
+        <button
+          type="button"
+          aria-expanded={showAll}
+          onClick={() => setShowAll(!showAll)}
+          className="flex h-8 w-full items-center gap-1.5 border-t border-content/10 px-3 text-left text-[11px] text-content/45 hover:bg-content/5 hover:text-content/70"
+        >
+          {showAll ? (
+            <ChevronDown className="size-3.5" />
+          ) : (
+            <ChevronRight className="size-3.5" />
+          )}
+          {showAll
+            ? "Show fewer tasks"
+            : `Show ${proposal.tasks.length - 3} more ${proposal.tasks.length === 4 ? "task" : "tasks"}`}
+        </button>
+      )}
+      {(error || proposal.error) && (
+        <p role="alert" className="px-3 py-2 text-[12px] text-red-400">
+          {error ?? proposal.error}
+        </p>
+      )}
+      {!planning && (
+        <div className="flex flex-wrap items-center justify-between gap-2 border-t border-content/10 px-3 py-2 text-[11px] text-content/45">
+          <div className="flex items-center gap-1.5">
+            {editable ? (
+              <>
+                <span>Parallel workers</span>
+                <div
+                  role="radiogroup"
+                  aria-label="Parallel workers"
+                  className="flex items-center gap-0.5 rounded-md bg-content/5 p-0.5"
+                >
+                  {[1, 2, 3, 4].map((number) => (
+                    <button
+                      key={number}
+                      type="button"
+                      role="radio"
+                      aria-checked={proposal.settings.maxWorkers === number}
+                      onClick={() =>
+                        actions?.update(proposal.leadId, block.id, {
+                          ...proposal,
+                          settings: {
+                            ...proposal.settings,
+                            maxWorkers: number,
+                          },
+                        })
+                      }
+                      className={`grid size-5 place-items-center rounded-[5px] text-[11px] leading-none tabular-nums ${
+                        proposal.settings.maxWorkers === number
+                          ? "bg-content/15 font-medium text-content"
+                          : "text-content/45 hover:bg-content/8 hover:text-content"
+                      }`}
+                    >
+                      {number}
+                    </button>
+                  ))}
+                </div>
+              </>
+            ) : (
+              <span>{proposal.settings.maxWorkers} parallel</span>
+            )}
+            <WorkerHelp />
+          </div>
+          <span>
+            {run?.status ??
+              (proposal.status === "approved"
+                ? "Approved"
+                : proposal.status === "ready"
+                  ? "Awaiting confirmation"
+                  : "")}{" "}
+            · Shared project folder
+          </span>
+        </div>
+      )}
+    </div>
+  );
+}
diff --git a/src/chrome/OrchestrationSidebarAgents.tsx b/src/chrome/OrchestrationSidebarAgents.tsx
new file mode 100644
index 00000000..79a3b715
--- /dev/null
+++ b/src/chrome/OrchestrationSidebarAgents.tsx
@@ -0,0 +1,253 @@
+import { useContext, useEffect, useState, useSyncExternalStore } from "react";
+import { findModel } from "../lib/models";
+import { orchestrator } from "../lib/orchestration";
+import {
+  orchestrationTaskLabel,
+  type OrchestrationSummary,
+} from "../lib/orchestrationSummary";
+import { HARNESS_TITLE } from "../lib/session";
+import { HarnessIcon } from "./HarnessIcon";
+import { OrchestrationWorkers } from "./OrchestrationActions";
+import { Check, ChevronDown, ChevronRight, CircleAlert } from "./icons";
+import { TerminalSpinner } from "./TerminalSpinner";
+
+export function OrchestrationSidebarAgents({
+  leadId,
+  summary,
+}: {
+  leadId: string;
+  summary: OrchestrationSummary;
+}) {
+  const workers = useContext(OrchestrationWorkers);
+  const runs = useSyncExternalStore(
+    orchestrator.subscribe,
+    orchestrator.snapshot,
+    orchestrator.snapshot,
+  );
+  const [error, setError] = useState<string>();
+  const [pending, setPending] = useState(false);
+  // Rows expand independently, so several agents can be watched side by side.
+  const [expanded, setExpanded] = useState<ReadonlySet<string>>(
+    () => new Set(),
+  );
+  // Revealing a worker from its toast opens that row without closing others.
+  const revealed = workers.selectedId;
+  useEffect(() => {
+    if (revealed)
+      setExpanded((current) =>
+        current.has(revealed) ? current : new Set(current).add(revealed),
+      );
+  }, [revealed]);
+  const toggle = (sessionId: string, isOpen: boolean) => {
+    setExpanded((current) => {
+      const next = new Set(current);
+      if (isOpen) next.delete(sessionId);
+      else next.add(sessionId);
+      return next;
+    });
+    if (isOpen && revealed === sessionId) workers.inspect(null);
+  };
+  // A saved run has no live entry, so the card stays read-only after a reload.
+  const run = runs.find((entry) => entry.leadId === leadId);
+  const perform = async (operation: () => Promise<void>) => {
+    setPending(true);
+    setError(undefined);
+    try {
+      await operation();
+    } catch (reason) {
+      setError(reason instanceof Error ? reason.message : String(reason));
+    } finally {
+      setPending(false);
+    }
+  };
+  const done = summary.tasks.filter(
+    (task) => task.status === "completed",
+  ).length;
+  const action =
+    "rounded px-1.5 py-0.5 text-[11px] text-content/55 hover:bg-content/10 hover:text-content disabled:opacity-35";
+  // Sits inside an already-lit row, so it needs its own surface to read as a
+  // button rather than as another line of text.
+  const solidAction =
+    "rounded bg-content/15 px-1.5 py-0.5 text-[11px] text-content/75 hover:bg-content/25 hover:text-content disabled:opacity-35";
+  return (
+    <div className="relative mt-1.5">
+      <div className="mb-0.5 px-0.5 flex items-center justify-between text-[11px] text-content/45">
+        <span>
+          {summary.tasks.length}{" "}
+          {summary.tasks.length === 1 ? "agent" : "agents"}
+        </span>
+        <span className="tabular-nums">
+          {done}/{summary.tasks.length} done
+        </span>
+      </div>
+      {/*
+        Offset by the rows' own padding so a chevron lands on the card's
+        content edge, under the harness icon of the header above.
+
+        No height cap and no scroller: the card grows with whatever the user
+        expanded, and the sidebar it sits in does the only scrolling. Nesting
+        a second scroll region here made rows clip mid-line.
+      */}
+      <div
+        aria-label="Orchestrated agents"
+        className="-mx-2 flex touch-pan-y flex-col gap-px"
+        onPointerDown={(event) => event.stopPropagation()}
+        onClick={(event) => event.stopPropagation()}
+      >
+        {summary.tasks.map((task) => {
+          // Something waiting on an answer opens itself; it cannot be missed.
+          const open = expanded.has(task.sessionId) || !!task.needsInput;
+          const live = run?.tasks.find(
+            (entry) => entry.sessionId === task.sessionId,
+          );
+          const label = orchestrationTaskLabel(task, summary);
+          const working =
+            summary.live && task.status === "running" && !task.needsInput;
+          // A saved provider model may not be in this window's catalog yet.
+          // Keep its identity instead of substituting the harness default.
+          const model = findModel(task.model)?.name ?? task.model;
+          return (
+            <div
+              key={task.sessionId}
+              data-orchestration-agent={task.sessionId}
+              // Expanding lights the whole row, header and detail together.
+              className={`rounded-md ${open ? "bg-content/10" : ""}`}
+            >
+              <button
+                type="button"
+                title={`${task.title} · ${HARNESS_TITLE[task.harness]} · ${model} · ${label}`}
+                aria-label={`Agent details: ${task.title}`}
+                aria-expanded={open}
+                onClick={() => toggle(task.sessionId, open)}
+                // Named, because the whole session card is already a `group`.
+                className={`group/agent flex w-full min-w-0 items-center gap-1.5 rounded-md px-2 py-1.5 text-left ${
+                  open ? "" : "hover:bg-content/10"
+                }`}
+              >
+                {/* One slot: the chevron stands in for the harness mark
+                    whenever this row is open or under the pointer. */}
+                <span className="grid size-3.5 shrink-0 place-items-center text-content/45">
+                  {open ? (
+                    <ChevronDown className="size-3" strokeWidth={1.75} />
+                  ) : (
+                    <>
+                      <HarnessIcon
+                        harness={task.harness}
+                        className="size-3.5 opacity-75 group-focus-visible/agent:hidden group-hover/agent:hidden"
+                      />
+                      <ChevronRight
+                        className="hidden size-3 group-focus-visible/agent:block group-hover/agent:block"
+                        strokeWidth={1.75}
+                      />
+                    </>
+                  )}
+                </span>
+                <span className="min-w-0 flex-1 truncate text-[12px] leading-snug text-content/80">
+                  {task.title}
+                </span>
+                <span
+                  className={`flex shrink-0 items-center gap-1 text-[11px] ${
+                    task.needsInput || task.status === "failed"
+                      ? "text-amber-400"
+                      : working
+                        ? "text-accent"
+                        : task.status === "completed"
+                          ? "text-emerald-400"
+                          : "text-content/45"
+                  }`}
+                >
+                  {task.needsInput || task.status === "failed" ? (
+                    <CircleAlert className="size-3" strokeWidth={1.75} />
+                  ) : working ? (
+                    <TerminalSpinner className="inline-block w-3 select-none text-center text-[11px] leading-none text-accent" />
+                  ) : task.status === "completed" ? (
+                    <Check className="size-3" strokeWidth={2.25} />
+                  ) : null}
+                  <span>{label}</span>
+                </span>
+              </button>
+              {/* Indented to the title's column: the icon slot and its gap. */}
+              {open && (
+                <div className="space-y-2 pb-3 pl-6.5 pr-2">
+                  <p
+                    className="flex min-w-0 items-center gap-1.5 text-[11px] text-content/45"
+                    title={`${model} · ${HARNESS_TITLE[task.harness]}`}
+                  >
+                    <HarnessIcon
+                      harness={task.harness}
+                      className="size-3.5 shrink-0"
+                    />
+                    <span className="min-w-0 truncate">{model}</span>
+                  </p>
+                  {live?.error && (
+                    <p className="text-[11px] text-red-400">{live.error}</p>
+                  )}
+                  <div className="flex flex-wrap items-center gap-1">
+                    {workers.openDetails && (
+                      <button
+                        type="button"
+                        title="Open this agent beside the orchestrator"
+                        className={solidAction}
+                        onClick={() =>
+                          workers.openDetails?.({
+                            sessionId: task.sessionId,
+                            leadId,
+                            title: task.title,
+                            harness: task.harness,
+                          })
+                        }
+                      >
+                        See details
+                      </button>
+                    )}
+                    {live && ["queued", "running"].includes(live.status) && (
+                      <button
+                        type="button"
+                        className={solidAction}
+                        disabled={pending}
+                        onClick={() =>
+                          void perform(() =>
+                            orchestrator.cancelTask(leadId, live.id),
+                          )
+                        }
+                      >
+                        Cancel task
+                      </button>
+                    )}
+                  </div>
+                </div>
+              )}
+            </div>
+          );
+        })}
+      </div>
+      {(error || run?.error) && (
+        <p role="alert" className="py-1 text-[11px] text-red-400">
+          {error ?? run?.error}
+        </p>
+      )}
+      {/* Stopping a run belongs to the composer, which stops the lead and its
+          agents together. Resume has no other home, so it stays. */}
+      {run?.status === "paused" && (
+        <div className="-mr-1.5 mt-0.5 flex items-center justify-end">
+          <button
+            type="button"
+            className={action}
+            disabled={pending}
+            onClick={() =>
+              void perform(() =>
+                orchestrator.start(
+                  leadId,
+                  run.allowedHarnesses,
+                  run.maxWorkers,
+                ),
+              )
+            }
+          >
+            Resume
+          </button>
+        </div>
+      )}
+    </div>
+  );
+}
diff --git a/src/chrome/Sidebar.tsx b/src/chrome/Sidebar.tsx
index 38cc0f48..8a210c09 100644
--- a/src/chrome/Sidebar.tsx
+++ b/src/chrome/Sidebar.tsx
@@ -1,3 +1,4 @@
+import { OrchestrationSidebarAgents } from "./OrchestrationSidebarAgents";
 import { openUrl } from "@tauri-apps/plugin-opener";
 import {
   Archive,
@@ -426,7 +427,7 @@ function SidebarComponent({
     sessions,
     openSessions,
     sessionFolders,
-  );
+  ).filter((session) => !session.orchestrationLeadId);
   const visibleSessions = [
     ...filterSessionsByQuery(
       filterSessionsByStatus(
@@ -2348,12 +2349,16 @@ function SessionCard({
   const skipClickUntil = useRef(0);
   const prefetchTimer = useRef<number | null>(null);
   const [dragging, setDragging] = useState(false);
+  const orchestration = session.orchestration;
   const title = sessionDisplayTitle(session.title, session.harness);
   const gitLabel = formatGitLabel(session.repo, session.branch);
   const time = formatRelative(session.updatedAt, now);
-  const model = compact
-    ? null
-    : resolveModel(session.harness, session.model).name;
+  // A lead card always shows its model, even compact: it heads a group of
+  // agents that each name theirs, so the row naming none reads as a gap.
+  const model =
+    compact && !orchestration
+      ? null
+      : resolveModel(session.harness, session.model).name;
   const statusClass = needsApproval
     ? "text-amber-400"
     : busy
@@ -2368,7 +2373,7 @@ function SessionCard({
       {needsApproval ? (
         <>
           <CircleAlert className="size-3" strokeWidth={1.75} />
-          <span>Need approval</span>
+          <span>{orchestration ? "Needs input" : "Need approval"}</span>
         </>
       ) : busy ? (
         <>
@@ -2579,16 +2584,18 @@ function SessionCard({
   };
 
   const archiveLabel = session.archived ? "Unarchive" : "Archive";
+  const cardPaddingY = orchestration
+    ? "py-2.5"
+    : compact
+      ? "py-1.5"
+      : "py-2";
 
   return (
     <div className="group relative">
       <div
-        role="button"
-        tabIndex={0}
         title={title}
-        aria-current={isActive ? "true" : undefined}
-        aria-pressed={isSelected}
         data-session-card={session.id}
+        data-orchestration-card={orchestration ? "true" : undefined}
         data-session-selected={isSelected ? "true" : undefined}
         data-tauri-drag-region="false"
         onPointerDown={onPointerDown}
@@ -2599,10 +2606,9 @@ function SessionCard({
           onSelect(session.id, event);
         }}
         onContextMenu={onContextMenu}
-        onKeyDown={onKeyDown}
-        className={`relative border flex w-full cursor-default select-none touch-none flex-col rounded-md px-2.5 text-left ${
-          compact ? "py-1.5" : "py-2"
-        } ${dragging ? "opacity-40" : ""} ${
+        className={`relative border flex w-full cursor-default select-none touch-none flex-col rounded-md px-2.5 text-left ${cardPaddingY} ${
+          dragging ? "opacity-40" : ""
+        } ${
           dropTarget
             ? "text-content border-transparent"
             : isSelected
@@ -2611,50 +2617,71 @@ function SessionCard({
                 ? "bg-content/20 text-content border-content/30 border-dashed"
                 : isActive
                   ? "bg-content/10 text-content border-transparent"
-                  : "text-content/80 hover:bg-content/5 hover:text-content border-transparent"
+                  : // A lead rests at the tone others only reach on hover, so
+                    // its card reads as a group even when nothing is selected.
+                    `text-content/80 hover:text-content border-transparent ${
+                      orchestration
+                        ? "bg-content/5 hover:bg-content/10"
+                        : "hover:bg-content/5"
+                    }`
         }`}
       >
         {dropTarget ? (
           <div className="pointer-events-none absolute inset-0 rounded-md bg-accent/20" />
         ) : null}
-        {compact ? null : (
-          <span className="relative flex items-center gap-2">
-            <span className="flex min-w-0 flex-1 items-center gap-1.5">
-              <HarnessIcon
-                harness={session.harness}
-                className="size-3.5 shrink-0"
-              />
-              <span className="min-w-0 truncate text-[11px] text-content/50">
-                {model}
+        <div
+          role="button"
+          tabIndex={0}
+          aria-current={isActive ? "true" : undefined}
+          aria-pressed={isSelected}
+          data-session-select={session.id}
+          onKeyDown={onKeyDown}
+        >
+          {compact && !orchestration ? null : (
+            <span className="relative flex items-center gap-2">
+              <span className="flex min-w-0 flex-1 items-center gap-1.5">
+                <HarnessIcon
+                  harness={session.harness}
+                  className="size-3.5 shrink-0"
+                />
+                <span className="min-w-0 truncate text-[11px] text-content/50">
+                  {model}
+                </span>
+              </span>
+              <span className="flex shrink-0 items-center gap-1.5">
+                {linkedUpdateDot}
+                {status}
               </span>
             </span>
-            <span className="flex shrink-0 items-center gap-1.5">
-              {linkedUpdateDot}
-              {status}
+          )}
+          <span
+            className={`relative flex min-w-0 items-center gap-1.5 ${
+              compact && !orchestration ? "" : "mt-1"
+            }`}
+          >
+            {session.pinned ? (
+              <Pin
+                className="size-3 shrink-0 text-content/45"
+                strokeWidth={1.75}
+              />
+            ) : null}
+            <span className="min-w-0 flex-1 line-clamp-1 text-[13px] font-semibold leading-snug text-content">
+              {title}
             </span>
+            {compact && !orchestration ? (
+              <span className="flex shrink-0 items-center gap-1.5">
+                {linkedUpdateDot}
+                {status}
+              </span>
+            ) : null}
           </span>
-        )}
-        <span
-          className={`relative flex min-w-0 items-center gap-1.5 ${
-            compact ? "" : "mt-1"
-          }`}
-        >
-          {session.pinned ? (
-            <Pin
-              className="size-3 shrink-0 text-content/45"
-              strokeWidth={1.75}
-            />
-          ) : null}
-          <span className="min-w-0 flex-1 line-clamp-1 text-[13px] font-semibold leading-snug text-content">
-            {title}
-          </span>
-          {compact ? (
-            <span className="flex shrink-0 items-center gap-1.5">
-              {linkedUpdateDot}
-              {status}
-            </span>
-          ) : null}
-        </span>
+        </div>
+        {orchestration ? (
+          <OrchestrationSidebarAgents
+            leadId={session.id}
+            summary={orchestration}
+          />
+        ) : null}
         <span className="relative mt-1 flex items-center gap-2">
           {gitLabel ? (
             <span className="flex min-w-0 flex-1 items-center gap-1 text-[11px] text-content/45">
diff --git a/src/chrome/SidebarRename.test.ts b/src/chrome/SidebarRename.test.ts
index 599b269e..bd07b003 100644
--- a/src/chrome/SidebarRename.test.ts
+++ b/src/chrome/SidebarRename.test.ts
@@ -163,7 +163,7 @@ describe("sidebar session rename", () => {
 
   it("allows F2 to rename a working conversation", () => {
     act(() => render());
-    pressKey(card(), "F2");
+    pressKey(card().querySelector('[data-session-select]')!, "F2");
     const input = renameInput();
     expect(input.disabled).toBe(false);
     expect(document.activeElement === input).toBe(true);
@@ -374,6 +374,167 @@ describe("sidebar pinned sessions", () => {
   });
 });
 
+describe("sidebar orchestration card", () => {
+  it.each([false, true])(
+    "keeps agents inside a distinct lead card (pinned=%s)",
+    (pinned) => {
+      props.onArchiveSession = vi.fn();
+      props.linkedSessionUpdateIds = new Set(["session-1"]);
+      const lead = {
+        ...props.sessions[0],
+        pinned,
+        linkedWorkItem: {
+          kind: "pr" as const,
+          repo: "acme/app",
+          number: 42,
+          url: "https://github.com/acme/app/pull/42",
+        },
+        orchestration: {
+          status: "active" as const,
+          live: true,
+          tasks: [
+            {
+              sessionId: "worker-a",
+              title: "Build settings",
+              harness: "codex" as const,
+              model: "codex:worker-a",
+              status: "running" as const,
+            },
+            {
+              sessionId: "worker-b",
+              title: "Review changes",
+              harness: "claude" as const,
+              model: "claude:worker-b",
+              status: "running" as const,
+              needsInput: true,
+            },
+            {
+              sessionId: "worker-c",
+              title: "Check types",
+              harness: "codex" as const,
+              model: "codex:worker-c",
+              status: "completed" as const,
+            },
+          ],
+        },
+      };
+      props.sessions = [
+        lead,
+        { ...props.sessions[0], id: "unrelated" },
+        {
+          ...props.sessions[0],
+          id: "worker-a",
+          orchestrationLeadId: lead.id,
+        },
+      ];
+      act(() => render());
+      expect(container.querySelectorAll("[data-session-card]")).toHaveLength(2);
+      expect(card().dataset.orchestrationCard).toBe("true");
+      // The lead card carries the sidebar's ordinary active treatment.
+      expect(card().className).toContain("bg-content/10");
+      // The lead names its own model, like every agent row beneath it.
+      expect(card().textContent).toContain("Claude Sonnet 5");
+      expect(card().textContent).not.toContain("Orchestrator");
+      expect(card().textContent).toContain("3 agents");
+      expect(card().textContent).toContain("1/3 done");
+      expect(card().textContent).toContain("Build settings");
+      expect(card().textContent).toContain("Needs input");
+      expect(
+        card().querySelector('[aria-label="Linked work item updated"]'),
+      ).not.toBeNull();
+      const archive = card().querySelector<HTMLButtonElement>(
+        '[aria-label^="Archive "]',
+      )!;
+      const pullRequest = card().querySelector('[aria-label="Open PR #42"]');
+      expect(card().querySelectorAll('[aria-label^="Archive "]')).toHaveLength(
+        1,
+      );
+      expect(card().lastElementChild?.contains(pullRequest)).toBe(true);
+      expect(archive.nextElementSibling).toBe(pullRequest);
+      act(() => archive.click());
+      expect(props.onArchiveSession).toHaveBeenCalledExactlyOnceWith(
+        lead.id,
+        true,
+      );
+      expect(props.onSelectSession).not.toHaveBeenCalled();
+      // A collapsed row stays one line; the model rides along in the tooltip.
+      expect(
+        card()
+          .querySelector('[data-orchestration-agent="worker-a"] button')
+          ?.getAttribute("title"),
+      ).toContain("codex:worker-a");
+      expect(
+        card().querySelectorAll("[data-orchestration-agent]"),
+      ).toHaveLength(3);
+      const normal = container.querySelector<HTMLElement>(
+        '[data-session-card="unrelated"]',
+      )!;
+      expect(normal.hasAttribute("data-orchestration-card")).toBe(false);
+      expect(normal.querySelector("[data-orchestration-agent]")).toBeNull();
+      // Working the agents list is not a request to open the lead's tab: the
+      // row expands in place and the card stays where it is.
+      const agentRow = card().querySelector<HTMLButtonElement>(
+        '[data-orchestration-agent="worker-a"] button',
+      )!;
+      expect(card().hasAttribute("role")).toBe(false);
+      for (const action of card().querySelectorAll('button, [role="button"]')) {
+        expect(
+          action.parentElement?.closest('button, [role="button"]'),
+        ).toBeNull();
+      }
+      const selection = card().querySelector<HTMLElement>(
+        '[data-session-select]',
+      )!;
+      act(() => selection.focus());
+      expect(document.activeElement).toBe(selection);
+      expect(pressKey(selection, "Enter").defaultPrevented).toBe(true);
+      expect(props.onSelectSession).toHaveBeenCalledWith(lead.id);
+      vi.mocked(props.onSelectSession).mockClear();
+      expect(pressKey(agentRow, "Enter").defaultPrevented).toBe(false);
+      expect(props.onSelectSession).not.toHaveBeenCalled();
+      const wasOpen = agentRow.getAttribute("aria-expanded");
+      act(() => agentRow.click());
+      expect(props.onSelectSession).not.toHaveBeenCalled();
+      expect(
+        card()
+          .querySelector('[data-orchestration-agent="worker-a"] button')
+          ?.getAttribute("aria-expanded"),
+      ).not.toBe(wasOpen);
+      // A blocked agent stays expanded while it needs the lead's attention.
+      expect(
+        card()
+          .querySelector('[data-orchestration-agent="worker-b"] button')
+          ?.getAttribute("aria-expanded"),
+      ).toBe("true");
+      props.approvalSessionIds = new Set([lead.id]);
+      act(() => render());
+      expect(card().className).toContain("border-dashed");
+      expect(card().textContent).toContain("Needs input");
+    },
+  );
+
+  it("renders saved worker details without claiming the workers are running", () => {
+    props.busySessionIds = new Set();
+    props.sessions[0].orchestration = {
+      status: "active",
+      tasks: [
+        {
+          sessionId: "worker",
+          title: "Saved task",
+          harness: "codex",
+          model: "codex:test",
+          status: "running",
+        },
+      ],
+    };
+    act(() => render());
+    expect(card().textContent).toContain("Saved task");
+    expect(card().textContent).toContain("Saved");
+    expect(card().textContent).not.toContain("Working");
+    expect(card().querySelector(".motion-safe\\:animate-pulse")).toBeNull();
+  });
+});
+
 describe("sidebar linked work item updates", () => {
   it("uses the footer for the linked issue or PR instead of a second harness icon", () => {
     props.busySessionIds = new Set();
diff --git a/src/chrome/SurfaceTabs.tsx b/src/chrome/SurfaceTabs.tsx
index eb42884b..f23c9e9b 100644
--- a/src/chrome/SurfaceTabs.tsx
+++ b/src/chrome/SurfaceTabs.tsx
@@ -5,6 +5,7 @@ import { useLayoutEffect, useRef, useState } from "react";
 import { copyText } from "../lib/clipboard";
 import { basename, revealPath } from "../lib/fs";
 import {
+  isAgentTab,
   isChangesTab,
   isCommitTab,
   isFilesystemTab,
@@ -23,6 +24,7 @@ import { useLockOverscroll } from "../hooks/useLockOverscroll";
 import { useAnimatedReorder } from "../hooks/useAnimatedReorder";
 import { ExplorerMenu, type ExplorerMenuItem } from "./ExplorerMenu";
 import { FileTypeIcon } from "./FileTypeIcon";
+import { HarnessIcon } from "./HarnessIcon";
 
 type Props = {
   files: FilePaneTab[];
@@ -124,6 +126,16 @@ export function surfaceTabPresentation(
     };
   }
 
+  if (isAgentTab(file)) {
+    const name = file.path.trim() || "Agent";
+    return {
+      name,
+      label: name,
+      iconName: "AGENT",
+      tooltip: `${name} — orchestration agent`,
+    };
+  }
+
   if (isCommitTab(file)) {
     const name = file.commit.subject.trim() || file.commit.shortSha;
     return {
@@ -263,6 +275,7 @@ export function SurfaceTabs({
         const commit = isCommitTab(file);
         const review = isReviewTab(file) && !changes;
         const terminal = isTerminalTab(file);
+        const agent = isAgentTab(file) ? file.agent : null;
         const { label, iconName, tooltip } = surfaceTabPresentation(file);
         return (
           <div
@@ -323,6 +336,11 @@ export function SurfaceTabs({
             >
               {terminal ? (
                 <Terminal className="size-3.5 shrink-0" strokeWidth={1.75} />
+              ) : agent ? (
+                <HarnessIcon
+                  harness={agent.harness}
+                  className="size-3.5 shrink-0"
+                />
               ) : changes || commit ? (
                 <GitCompare className="size-3.5 shrink-0" strokeWidth={1.75} />
               ) : (
diff --git a/src/chrome/icons.tsx b/src/chrome/icons.tsx
index 13c2c4bd..4819c148 100644
--- a/src/chrome/icons.tsx
+++ b/src/chrome/icons.tsx
@@ -50,6 +50,7 @@ import GitMergeIcon from "@hugeicons/core-free-icons/GitMergeIcon";
 import GitPullRequestClosedIcon from "@hugeicons/core-free-icons/GitPullRequestClosedIcon";
 import GitPullRequestDraftIcon from "@hugeicons/core-free-icons/GitPullRequestDraftIcon";
 import GitPullRequestIcon from "@hugeicons/core-free-icons/GitPullRequestIcon";
+import HelpCircleIcon from "@hugeicons/core-free-icons/HelpCircleIcon";
 import ImageAdd01Icon from "@hugeicons/core-free-icons/ImageAdd01Icon";
 import InboxIcon from "@hugeicons/core-free-icons/InboxIcon";
 import KeyboardIcon from "@hugeicons/core-free-icons/KeyboardIcon";
@@ -79,6 +80,7 @@ import ReplaceIcon from "@hugeicons/core-free-icons/ReplaceIcon";
 import RotateCcwIcon from "@hugeicons/core-free-icons/RotateCcwIcon";
 import Search01Icon from "@hugeicons/core-free-icons/Search01Icon";
 import Settings01Icon from "@hugeicons/core-free-icons/Settings01Icon";
+import Share02Icon from "@hugeicons/core-free-icons/Share02Icon";
 import SidebarRight01Icon from "@hugeicons/core-free-icons/SidebarRight01Icon";
 import SparklesIcon from "@hugeicons/core-free-icons/SparklesIcon";
 import SquareIcon from "@hugeicons/core-free-icons/SquareIcon";
@@ -163,6 +165,7 @@ export const ChevronUp = wrap(ArrowUp01Icon, "ChevronUp");
 export const CircleAlert = wrap(AlertCircleIcon, "CircleAlert");
 export const CircleDashed = wrap(CircleDashedIcon, "CircleDashed");
 export const CircleDot = wrap(CircleDotIcon, "CircleDot");
+export const CircleHelp = wrap(HelpCircleIcon, "CircleHelp");
 export const CircleX = wrap(CancelCircleIcon, "CircleX");
 export const CloudUpload = wrap(CloudUploadIcon, "CloudUpload");
 export const Clock = wrap(Clock01Icon, "Clock");
@@ -231,6 +234,7 @@ export const Replace = wrap(ReplaceIcon, "Replace");
 export const RotateCcw = wrap(RotateCcwIcon, "RotateCcw");
 export const Search = wrap(Search01Icon, "Search");
 export const Settings = wrap(Settings01Icon, "Settings");
+export const Share = wrap(Share02Icon, "Share");
 export const SlidersHorizontal = wrap(
   PreferenceHorizontalIcon,
   "SlidersHorizontal",
diff --git a/src/hooks/useLockOverscroll.test.ts b/src/hooks/useLockOverscroll.test.ts
index e7eeb351..bee16481 100644
--- a/src/hooks/useLockOverscroll.test.ts
+++ b/src/hooks/useLockOverscroll.test.ts
@@ -1,55 +1,200 @@
+// @vitest-environment happy-dom
 import { describe, expect, it } from "vitest";
+import {
+  atScrollEdge,
+  hasScrollRoom,
+  lockOverscroll,
+} from "./useLockOverscroll";
 
-function shouldPreventWheel(
-  el: Pick<HTMLElement, "scrollTop" | "scrollLeft" | "clientHeight" | "clientWidth" | "scrollHeight" | "scrollWidth">,
-  e: Pick<WheelEvent, "deltaX" | "deltaY">,
-) {
-  const canScrollX = el.scrollWidth > el.clientWidth + 1;
-  const canScrollY = el.scrollHeight > el.clientHeight + 1;
-  const atTop = canScrollY && el.scrollTop <= 0 && e.deltaY < 0;
-  const atBottom =
-    canScrollY &&
-    el.scrollTop + el.clientHeight >= el.scrollHeight - 1 &&
-    e.deltaY > 0;
-  const atLeft = canScrollX && el.scrollLeft <= 0 && e.deltaX < 0;
-  const atRight =
-    canScrollX &&
-    el.scrollLeft + el.clientWidth >= el.scrollWidth - 1 &&
-    e.deltaX > 0;
-  return atTop || atBottom || atLeft || atRight;
+const box = (over: Partial<Record<string, number>> = {}) => ({
+  scrollTop: 0,
+  scrollLeft: 0,
+  clientHeight: 400,
+  clientWidth: 400,
+  scrollHeight: 800,
+  scrollWidth: 400,
+  ...over,
+});
+
+/** happy-dom reports 0 for every layout box, so the sizes are declared. */
+function sized(el: HTMLElement, sizes: Record<string, number>) {
+  for (const [name, value] of Object.entries(sizes)) {
+    Object.defineProperty(el, name, { value, configurable: true });
+  }
+  return el;
 }
 
 describe("useLockOverscroll wheel guard", () => {
-  it("does not block horizontal wheel on vertically scrolling containers", () => {
-    const el = {
-      scrollTop: 0,
-      scrollLeft: 0,
-      clientHeight: 400,
-      clientWidth: 400,
-      scrollHeight: 800,
-      scrollWidth: 400,
-    };
+  it.each(["svg", "path"])(
+    "allows scrolling a nested container through an SVG %s target",
+    (tag) => {
+      const outer = sized(
+        document.createElement("div"),
+        box({ scrollTop: 400 }),
+      );
+      const inner = sized(document.createElement("div"), box());
+      inner.style.overflowY = "auto";
+      const svg = document.createElementNS("http://www.w3.org/2000/svg", "svg");
+      const path = document.createElementNS(
+        "http://www.w3.org/2000/svg",
+        "path",
+      );
+      svg.append(path);
+      inner.append(svg);
+      outer.append(inner);
+      document.body.append(outer);
+      const detach = lockOverscroll(outer);
+      const wheel = new WheelEvent("wheel", {
+        deltaY: 40,
+        bubbles: true,
+        cancelable: true,
+      });
+      (tag === "svg" ? svg : path).dispatchEvent(wheel);
+      expect(wheel.defaultPrevented).toBe(false);
+      detach();
+      outer.remove();
+    },
+  );
+
+  it.each([
+    {
+      overflowX: "auto",
+      overflowY: "hidden",
+      deltaX: 0,
+      deltaY: 40,
+      blocked: true,
+    },
+    {
+      overflowX: "hidden",
+      overflowY: "auto",
+      deltaX: 40,
+      deltaY: 0,
+      blocked: true,
+    },
+    {
+      overflowX: "auto",
+      overflowY: "hidden",
+      deltaX: 0,
+      deltaY: -40,
+      blocked: true,
+    },
+    {
+      overflowX: "hidden",
+      overflowY: "auto",
+      deltaX: -40,
+      deltaY: 0,
+      blocked: true,
+    },
+    {
+      overflowX: "auto",
+      overflowY: "hidden",
+      deltaX: 40,
+      deltaY: 40,
+      blocked: false,
+    },
+    {
+      overflowX: "hidden",
+      overflowY: "auto",
+      deltaX: 40,
+      deltaY: 40,
+      blocked: false,
+    },
+  ])(
+    "matches nested overflow to the gesture's axis ($overflowX, $overflowY, $deltaX, $deltaY)",
+    ({ overflowX, overflowY, deltaX, deltaY, blocked }) => {
+      const outer = sized(
+        document.createElement("div"),
+        box({
+          scrollTop: deltaY < 0 ? 0 : 400,
+          scrollLeft: deltaX < 0 ? 0 : 400,
+          scrollWidth: 800,
+        }),
+      );
+      const inner = sized(
+        document.createElement("div"),
+        box({ scrollTop: 100, scrollLeft: 100, scrollWidth: 800 }),
+      );
+      Object.assign(inner.style, { overflowX, overflowY });
+      outer.append(inner);
+      document.body.append(outer);
+      const detach = lockOverscroll(outer);
+      const wheel = new WheelEvent("wheel", {
+        deltaX,
+        deltaY,
+        bubbles: true,
+        cancelable: true,
+      });
+      inner.dispatchEvent(wheel);
+      expect(wheel.defaultPrevented).toBe(blocked);
+      detach();
+      outer.remove();
+    },
+  );
 
-    expect(shouldPreventWheel(el, { deltaX: 40, deltaY: 0 })).toBe(false);
-    expect(shouldPreventWheel(el, { deltaX: -40, deltaY: 0 })).toBe(false);
+  it("does not block horizontal wheel on vertically scrolling containers", () => {
+    expect(atScrollEdge(box(), { deltaX: 40, deltaY: 0 })).toBe(false);
+    expect(atScrollEdge(box(), { deltaX: -40, deltaY: 0 })).toBe(false);
   });
 
   it("still blocks vertical rubber-band at the top and bottom", () => {
-    const el = {
-      scrollTop: 0,
-      scrollLeft: 0,
+    expect(atScrollEdge(box(), { deltaX: 0, deltaY: -40 })).toBe(true);
+    expect(
+      atScrollEdge(box({ scrollTop: 400 }), { deltaX: 0, deltaY: 40 }),
+    ).toBe(true);
+  });
+
+  it("reads room in the direction the wheel is pushing", () => {
+    expect(hasScrollRoom(box(), { deltaX: 0, deltaY: 40 })).toBe(true);
+    expect(hasScrollRoom(box(), { deltaX: 0, deltaY: -40 })).toBe(false);
+    expect(
+      hasScrollRoom(box({ scrollTop: 400 }), { deltaX: 0, deltaY: 40 }),
+    ).toBe(false);
+  });
+
+  it("leaves the gesture alone when a scroller inside still has room", () => {
+    // A pinned transcript with a part-scrolled field in it: cancelling the
+    // wheel here would cancel the field's own scrolling too.
+    const scroller = sized(document.createElement("div"), {
+      scrollTop: 400,
       clientHeight: 400,
-      clientWidth: 400,
       scrollHeight: 800,
+      clientWidth: 400,
       scrollWidth: 400,
-    };
+    });
+    const field = sized(document.createElement("textarea"), {
+      scrollTop: 0,
+      clientHeight: 160,
+      scrollHeight: 600,
+      clientWidth: 400,
+      scrollWidth: 400,
+    });
+    field.style.overflowY = "auto";
+    scroller.append(field);
+    document.body.append(scroller);
+    const detach = lockOverscroll(scroller);
 
-    expect(shouldPreventWheel(el, { deltaX: 0, deltaY: -40 })).toBe(true);
+    const down = new WheelEvent("wheel", {
+      deltaY: 40,
+      bubbles: true,
+      cancelable: true,
+    });
+    field.dispatchEvent(down);
+    expect(down.defaultPrevented).toBe(false);
 
-    const atBottom = {
-      ...el,
-      scrollTop: 400,
-    };
-    expect(shouldPreventWheel(atBottom, { deltaX: 0, deltaY: 40 })).toBe(true);
+    // Once the field bottoms out the lock takes over again.
+    Object.defineProperty(field, "scrollTop", {
+      value: 440,
+      configurable: true,
+    });
+    const spent = new WheelEvent("wheel", {
+      deltaY: 40,
+      bubbles: true,
+      cancelable: true,
+    });
+    field.dispatchEvent(spent);
+    expect(spent.defaultPrevented).toBe(true);
+
+    detach();
+    scroller.remove();
   });
 });
diff --git a/src/hooks/useLockOverscroll.ts b/src/hooks/useLockOverscroll.ts
index 5257ac95..c2a05fc8 100644
--- a/src/hooks/useLockOverscroll.ts
+++ b/src/hooks/useLockOverscroll.ts
@@ -1,31 +1,91 @@
 import { useCallback, useRef } from "react";
 
-/** Stop macOS rubber-band bounce when a scroller reaches any edge. */
+type Edges = Pick<
+  HTMLElement,
+  | "scrollTop"
+  | "scrollLeft"
+  | "clientHeight"
+  | "clientWidth"
+  | "scrollHeight"
+  | "scrollWidth"
+>;
+type Delta = Pick<WheelEvent, "deltaX" | "deltaY">;
+
+/** The scroller has run out of room in the direction the wheel is pushing. */
+export function atScrollEdge(el: Edges, e: Delta): boolean {
+  const canScrollX = el.scrollWidth > el.clientWidth + 1;
+  const canScrollY = el.scrollHeight > el.clientHeight + 1;
+  const atTop = canScrollY && el.scrollTop <= 0 && e.deltaY < 0;
+  const atBottom =
+    canScrollY &&
+    el.scrollTop + el.clientHeight >= el.scrollHeight - 1 &&
+    e.deltaY > 0;
+  const atLeft = canScrollX && el.scrollLeft <= 0 && e.deltaX < 0;
+  const atRight =
+    canScrollX &&
+    el.scrollLeft + el.clientWidth >= el.scrollWidth - 1 &&
+    e.deltaX > 0;
+  return atTop || atBottom || atLeft || atRight;
+}
+
+/** The scroller still has somewhere to go in the direction of the wheel. */
+export function hasScrollRoom(el: Edges, e: Delta): boolean {
+  if (e.deltaY < 0 && el.scrollTop > 0) return true;
+  if (e.deltaY > 0 && el.scrollTop + el.clientHeight < el.scrollHeight - 1) {
+    return true;
+  }
+  if (e.deltaX < 0 && el.scrollLeft > 0) return true;
+  return e.deltaX > 0 && el.scrollLeft + el.clientWidth < el.scrollWidth - 1;
+}
+
+function scrollable(node: HTMLElement, e: Delta): boolean {
+  const style = getComputedStyle(node);
+  return hasScrollRoom(node, {
+    deltaX: /auto|scroll|overlay/.test(style.overflowX) ? e.deltaX : 0,
+    deltaY: /auto|scroll|overlay/.test(style.overflowY) ? e.deltaY : 0,
+  });
+}
+
+/**
+ * A scroller between the wheel's target and `el` that can still take the
+ * gesture. Cancelling here would cancel it for that scroller too, since the
+ * browser picks what to scroll only after the event has finished dispatching.
+ */
+function innerScrollerTakes(el: HTMLElement, e: WheelEvent): boolean {
+  let node = e.target instanceof Element ? e.target : null;
+  while (node && node !== el) {
+    // Geometry first: it is free, and it rules out most of the ancestry
+    // before anything has to resolve style.
+    if (
+      node instanceof HTMLElement &&
+      hasScrollRoom(node, e) &&
+      scrollable(node, e)
+    )
+      return true;
+    node = node.parentElement;
+  }
+  return false;
+}
+
+/**
+ * Stop macOS rubber-band bounce when a scroller reaches any edge. Returns the
+ * detach, and stands alone from the hook so it can be exercised directly.
+ */
+export function lockOverscroll(el: HTMLElement): () => void {
+  const onWheel = (e: WheelEvent) => {
+    if (!atScrollEdge(el, e)) return;
+    if (innerScrollerTakes(el, e)) return;
+    e.preventDefault();
+  };
+  el.addEventListener("wheel", onWheel, { passive: false });
+  return () => el.removeEventListener("wheel", onWheel);
+}
+
 export function useLockOverscroll<T extends HTMLElement>() {
   const cleanup = useRef<(() => void) | null>(null);
 
   return useCallback((el: T | null) => {
     cleanup.current?.();
-    cleanup.current = null;
-    if (!el) return;
-
-    const onWheel = (e: WheelEvent) => {
-      const canScrollX = el.scrollWidth > el.clientWidth + 1;
-      const canScrollY = el.scrollHeight > el.clientHeight + 1;
-      const atTop = canScrollY && el.scrollTop <= 0 && e.deltaY < 0;
-      const atBottom =
-        canScrollY &&
-        el.scrollTop + el.clientHeight >= el.scrollHeight - 1 &&
-        e.deltaY > 0;
-      const atLeft = canScrollX && el.scrollLeft <= 0 && e.deltaX < 0;
-      const atRight =
-        canScrollX &&
-        el.scrollLeft + el.clientWidth >= el.scrollWidth - 1 &&
-        e.deltaX > 0;
-      if (atTop || atBottom || atLeft || atRight) e.preventDefault();
-    };
-
-    el.addEventListener("wheel", onWheel, { passive: false });
-    cleanup.current = () => el.removeEventListener("wheel", onWheel);
+    cleanup.current = el ? lockOverscroll(el) : null;
   }, []);
 }
diff --git a/src/lib/agentTabs.test.ts b/src/lib/agentTabs.test.ts
new file mode 100644
index 00000000..3b3d3872
--- /dev/null
+++ b/src/lib/agentTabs.test.ts
@@ -0,0 +1,82 @@
+import { describe, expect, it } from "vitest";
+import {
+  editorTabKey,
+  isAgentTab,
+  isFilesystemTab,
+  leafIds,
+  newAgentTab,
+  newFileTab,
+  newTab,
+  openEditorTab,
+} from "./layout";
+import { groupTurns } from "../surfaces/transcriptActivity";
+import type { Block } from "./session";
+
+const agent = (sessionId: string, title: string) =>
+  newAgentTab(title, "/repo", {
+    sessionId,
+    leadId: "lead",
+    harness: "codex",
+  });
+
+describe("agent tabs", () => {
+  it("gathers every agent of a run into one pane beside the lead", () => {
+    let tab = newTab("lead");
+    tab = openEditorTab(tab, agent("worker-a", "Audit the engine"));
+    const paneId = tab.editorPanes[0].id;
+    tab = openEditorTab(tab, agent("worker-b", "Audit the UI"));
+
+    expect(tab.editorPanes).toHaveLength(1);
+    expect(tab.editorPanes[0].id).toBe(paneId);
+    expect(tab.editorPanes[0].files.map((file) => file.path)).toEqual([
+      "Audit the engine",
+      "Audit the UI",
+    ]);
+    // The pane sits beside the lead, which keeps its own leaf.
+    expect(leafIds(tab.layout)).toEqual(["lead", paneId]);
+    expect(tab.focusedId).toBe(paneId);
+  });
+
+  it("focuses the tab an agent already has instead of opening a second", () => {
+    let tab = newTab("lead");
+    tab = openEditorTab(tab, agent("worker-a", "Audit the engine"));
+    tab = openEditorTab(tab, agent("worker-b", "Audit the UI"));
+    const first = tab.editorPanes[0].files[0];
+    tab = openEditorTab(tab, agent("worker-a", "Audit the engine"));
+
+    expect(tab.editorPanes[0].files).toHaveLength(2);
+    expect(tab.editorPanes[0].activeFileId).toBe(first.id);
+  });
+
+  it("is keyed by its worker, and is not a file on disk", () => {
+    const file = agent("worker-a", "Audit the engine");
+    expect(editorTabKey(file)).toBe("agent:worker-a");
+    expect(isAgentTab(file)).toBe(true);
+    expect(file.agent.harness).toBe("codex");
+    expect(isFilesystemTab(file)).toBe(false);
+    expect(isFilesystemTab(newFileTab("/repo/a.ts", "/repo"))).toBe(true);
+  });
+});
+
+describe("a worker's own transcript", () => {
+  const blocks: Block[] = [
+    { id: "u1", role: "user", text: "Audit the engine", internal: true },
+    { id: "a1", role: "assistant", text: "Looking now" },
+    { id: "u2", role: "user", text: "Also check retries", internal: true },
+    { id: "a2", role: "assistant", text: "Done" },
+  ];
+
+  it("shows the orchestrator's turns, which the lead's own transcript hides", () => {
+    expect(
+      groupTurns(blocks, true).map((turn) => turn.map((b) => b.id)),
+    ).toEqual([
+      ["u1", "a1"],
+      ["u2", "a2"],
+    ]);
+    // Without it the prompts vanish and the replies fold into one turn, which
+    // is what left the worker's answers with nothing above them.
+    expect(groupTurns(blocks).map((turn) => turn.map((b) => b.id))).toEqual([
+      ["a1", "a2"],
+    ]);
+  });
+});
diff --git a/src/lib/approvalToast.test.ts b/src/lib/approvalToast.test.ts
index 5a1ea98f..691a2de6 100644
--- a/src/lib/approvalToast.test.ts
+++ b/src/lib/approvalToast.test.ts
@@ -7,10 +7,7 @@ import {
 } from "./approvalToast";
 import { newSession, type Block } from "./session";
 
-function block(
-  role: Block["role"],
-  approval?: Block["approval"],
-): Block {
+function block(role: Block["role"], approval?: Block["approval"]): Block {
   return {
     id: crypto.randomUUID(),
     role,
@@ -23,6 +20,24 @@ function block(
 }
 
 describe("pendingApprovalForSession", () => {
+  it("never toasts a worker approval, which its lead answers instead", () => {
+    const worker = {
+      ...newSession(),
+      id: "worker",
+      orchestrationLeadId: "lead",
+      blocks: [block("tool", { requestId: 42 })],
+    };
+    const leadTab = newTab("lead");
+    const otherTab = newTab("unrelated");
+    const tabs = [leadTab, otherTab];
+    for (const active of [leadTab, otherTab])
+      expect(hiddenApprovalNotices([worker], active.id, tabs, true)).toEqual([]);
+    // The same approval on an ordinary session still reaches the user.
+    const solo = { ...worker, orchestrationLeadId: undefined };
+    expect(
+      hiddenApprovalNotices([solo], otherTab.id, tabs, true)[0].sessionId,
+    ).toBe("worker");
+  });
   it("returns the latest undecided approval", () => {
     const session = newSession();
     session.blocks = [
@@ -62,15 +77,15 @@ describe("isSessionConversationFocused", () => {
   it("is true only when the session pane is focused on the active tab", () => {
     const session = newSession();
     const tab = newTab(session.id);
-    expect(
-      isSessionConversationFocused(session.id, tab.id, [tab], true),
-    ).toBe(true);
-    expect(
-      isSessionConversationFocused(session.id, tab.id, [tab], false),
-    ).toBe(false);
-    expect(
-      isSessionConversationFocused("other", tab.id, [tab], true),
-    ).toBe(false);
+    expect(isSessionConversationFocused(session.id, tab.id, [tab], true)).toBe(
+      true,
+    );
+    expect(isSessionConversationFocused(session.id, tab.id, [tab], false)).toBe(
+      false,
+    );
+    expect(isSessionConversationFocused("other", tab.id, [tab], true)).toBe(
+      false,
+    );
   });
 });
 
diff --git a/src/lib/approvalToast.ts b/src/lib/approvalToast.ts
index d217f484..1ee1f5ab 100644
--- a/src/lib/approvalToast.ts
+++ b/src/lib/approvalToast.ts
@@ -62,6 +62,8 @@ export function hiddenApprovalNotices(
   const notices: Array<PendingApprovalNotice & { session: Session }> = [];
   for (const session of sessions) {
     if (session.inboxAsk) continue;
+    // An orchestrated worker answers to its lead, never to the user directly.
+    if (session.orchestrationLeadId) continue;
     const pending = pendingApprovalForSession(session);
     if (!pending) continue;
     if (
diff --git a/src/lib/harness/apply.ts b/src/lib/harness/apply.ts
index 2108d053..160dd082 100644
--- a/src/lib/harness/apply.ts
+++ b/src/lib/harness/apply.ts
@@ -354,12 +354,14 @@ function lastMatchingBlock(
 type UserTurnExtra = {
   secondOpinion?: Block["secondOpinion"];
   noteCard?: Block["noteCard"];
+  internal?: boolean;
 };
 
 function userTurnFields(extra?: UserTurnExtra) {
   return {
     ...(extra?.secondOpinion ? { secondOpinion: extra.secondOpinion } : {}),
     ...(extra?.noteCard ? { noteCard: extra.noteCard } : {}),
+    ...(extra?.internal ? { internal: true } : {}),
   };
 }
 
@@ -521,6 +523,16 @@ export function promoteLastAssistantToPlan(
 
 function stopBlockProgress(block: Block): Block {
   let stopped = block.streaming ? { ...block, streaming: false } : block;
+  if (stopped.orchestration?.status === "planning") {
+    stopped = {
+      ...stopped,
+      orchestration: {
+        ...stopped.orchestration,
+        status: "invalid",
+        error: "Planning was interrupted. Generate the assignments again.",
+      },
+    };
+  }
   if (stopped.role === "plan" && stopped.plan?.status === "streaming") {
     stopped = {
       ...stopped,
diff --git a/src/lib/harness/codex.ts b/src/lib/harness/codex.ts
index 5fb130c4..bf36b46d 100644
--- a/src/lib/harness/codex.ts
+++ b/src/lib/harness/codex.ts
@@ -415,6 +415,7 @@ async function ensureLive(input: HarnessSessionInput): Promise<Live> {
             ...buildThreadStartParams({
               cwd: input.cwd,
               runtimeMode: input.runtimeMode,
+              controlsAgents: input.controlsAgents,
               model,
               serviceTier,
             }),
@@ -434,6 +435,7 @@ async function ensureLive(input: HarnessSessionInput): Promise<Live> {
         buildThreadStartParams({
           cwd: input.cwd,
           runtimeMode: input.runtimeMode,
+          controlsAgents: input.controlsAgents,
           model,
           serviceTier,
         }),
@@ -497,6 +499,7 @@ async function runTurn(live: Live, input: SendTurnInput): Promise<void> {
   const params = buildTurnStartParams({
     threadId: live.threadId,
     runtimeMode: input.runtimeMode,
+    controlsAgents: input.controlsAgents,
     prompt: input.text.trim() || undefined,
     attachments: input.attachments,
     model,
diff --git a/src/lib/harness/codexProtocol.test.ts b/src/lib/harness/codexProtocol.test.ts
index fb8ba9aa..7c35f2f9 100644
--- a/src/lib/harness/codexProtocol.test.ts
+++ b/src/lib/harness/codexProtocol.test.ts
@@ -21,6 +21,21 @@ describe("runtimeModeToCodexConfig", () => {
     });
   });
 
+  it("opens loopback for a lead, since every sandbox denies network by default", () => {
+    // Without this an orchestration lead cannot reach its own control CLI.
+    for (const mode of ["supervised", "auto-accept-edits", "auto"] as const)
+      expect(
+        runtimeModeToCodexConfig(mode, true).sandboxPolicy,
+      ).toMatchObject({ networkAccess: true });
+    // Ordinary sessions keep the default, and full access needs no flag.
+    expect(runtimeModeToCodexConfig("auto").sandboxPolicy).not.toHaveProperty(
+      "networkAccess",
+    );
+    expect(runtimeModeToCodexConfig("full-access", true).sandboxPolicy).toEqual({
+      type: "dangerFullAccess",
+    });
+  });
+
   it("maps auto-accept-edits to workspace-write with user reviewer", () => {
     expect(runtimeModeToCodexConfig("auto-accept-edits")).toMatchObject({
       approvalPolicy: "on-request",
@@ -38,6 +53,45 @@ describe("runtimeModeToCodexConfig", () => {
     });
   });
 
+  it("opens the sandbox network only for a lead, which needs the control socket", () => {
+    // Both sandboxed policies default networkAccess to false, which denies
+    // loopback too, so the control CLI cannot reach MonoCode without this.
+    for (const mode of ["supervised", "auto-accept-edits", "auto"] as const) {
+      expect(runtimeModeToCodexConfig(mode).sandboxPolicy).not.toHaveProperty(
+        "networkAccess",
+      );
+      expect(runtimeModeToCodexConfig(mode, true).sandboxPolicy).toMatchObject({
+        networkAccess: true,
+      });
+    }
+    // full-access already permits it, and its policy takes no such field.
+    expect(runtimeModeToCodexConfig("full-access", true).sandboxPolicy).toEqual({
+      type: "dangerFullAccess",
+    });
+  });
+
+  it("carries the lead's network grant onto the turn, including a plan turn", () => {
+    expect(
+      buildTurnStartParams({
+        threadId: "t",
+        runtimeMode: "auto",
+        controlsAgents: true,
+      }).sandboxPolicy,
+    ).toMatchObject({ type: "workspaceWrite", networkAccess: true });
+    expect(
+      buildTurnStartParams({
+        threadId: "t",
+        runtimeMode: "auto",
+        controlsAgents: true,
+        intent: "plan",
+      }).sandboxPolicy,
+    ).toMatchObject({ type: "readOnly", networkAccess: true });
+    expect(
+      buildTurnStartParams({ threadId: "t", runtimeMode: "auto" })
+        .sandboxPolicy,
+    ).not.toHaveProperty("networkAccess");
+  });
+
   it("allows explicit escalation requests in full-access", () => {
     expect(runtimeModeToCodexConfig("full-access")).toMatchObject({
       approvalPolicy: "on-request",
diff --git a/src/lib/harness/codexProtocol.ts b/src/lib/harness/codexProtocol.ts
index d7faae95..cdf46e6f 100644
--- a/src/lib/harness/codexProtocol.ts
+++ b/src/lib/harness/codexProtocol.ts
@@ -27,12 +27,36 @@ export type CodexThreadConfig = {
   sandbox: "read-only" | "workspace-write" | "danger-full-access";
   approvalsReviewer: "user" | "auto_review";
   sandboxPolicy:
-    | { type: "readOnly" }
-    | { type: "workspaceWrite" }
+    | { type: "readOnly"; networkAccess?: boolean }
+    | { type: "workspaceWrite"; networkAccess?: boolean }
     | { type: "dangerFullAccess" };
 };
 
-export function runtimeModeToCodexConfig(mode: RuntimeMode): CodexThreadConfig {
+/**
+ * `readOnly` and `workspaceWrite` both default to networkAccess: false, which
+ * blocks loopback too. An orchestration lead has to reach the control CLI's
+ * socket, so it opts in; every other session keeps the default.
+ */
+function withNetwork(
+  config: CodexThreadConfig,
+  controlsAgents?: boolean,
+): CodexThreadConfig {
+  if (!controlsAgents || config.sandboxPolicy.type === "dangerFullAccess")
+    return config;
+  return {
+    ...config,
+    sandboxPolicy: { ...config.sandboxPolicy, networkAccess: true },
+  };
+}
+
+export function runtimeModeToCodexConfig(
+  mode: RuntimeMode,
+  controlsAgents?: boolean,
+): CodexThreadConfig {
+  return withNetwork(baseCodexConfig(mode), controlsAgents);
+}
+
+function baseCodexConfig(mode: RuntimeMode): CodexThreadConfig {
   switch (mode) {
     case "supervised":
       return {
@@ -70,14 +94,19 @@ export function runtimeModeToCodexConfig(mode: RuntimeMode): CodexThreadConfig {
 export function buildThreadStartParams(input: {
   cwd: string;
   runtimeMode: RuntimeMode;
+  controlsAgents?: boolean;
   model?: string;
   serviceTier?: string;
 }): Record<string, unknown> {
-  const config = runtimeModeToCodexConfig(input.runtimeMode);
+  const config = runtimeModeToCodexConfig(
+    input.runtimeMode,
+    input.controlsAgents,
+  );
   return {
     cwd: input.cwd,
     approvalPolicy: config.approvalPolicy,
     sandbox: config.sandbox,
+    sandboxPolicy: config.sandboxPolicy,
     approvalsReviewer: config.approvalsReviewer,
     ...(input.model ? { model: input.model } : {}),
     ...(input.serviceTier && input.serviceTier !== "default"
@@ -102,6 +131,7 @@ export function buildTurnSteerParams(input: {
 export function buildTurnStartParams(input: {
   threadId: string;
   runtimeMode: RuntimeMode;
+  controlsAgents?: boolean;
   prompt?: string;
   attachments?: Attachment[];
   model?: string;
@@ -109,15 +139,21 @@ export function buildTurnStartParams(input: {
   serviceTier?: string;
   intent?: TurnIntent;
 }): Record<string, unknown> {
-  const runtimeConfig = runtimeModeToCodexConfig(input.runtimeMode);
+  const runtimeConfig = runtimeModeToCodexConfig(
+    input.runtimeMode,
+    input.controlsAgents,
+  );
   const config: CodexThreadConfig =
     input.intent === "plan"
-      ? {
-          approvalPolicy: "never",
-          sandbox: "read-only",
-          approvalsReviewer: runtimeConfig.approvalsReviewer,
-          sandboxPolicy: { type: "readOnly" },
-        }
+      ? withNetwork(
+          {
+            approvalPolicy: "never",
+            sandbox: "read-only",
+            approvalsReviewer: runtimeConfig.approvalsReviewer,
+            sandboxPolicy: { type: "readOnly" },
+          },
+          input.controlsAgents,
+        )
       : runtimeConfig;
   return {
     threadId: input.threadId,
diff --git a/src/lib/harness/registry.ts b/src/lib/harness/registry.ts
index 648165b2..5b07953d 100644
--- a/src/lib/harness/registry.ts
+++ b/src/lib/harness/registry.ts
@@ -1,4 +1,5 @@
 import type { HarnessId } from "../session";
+import { invoke, isTauri } from "@tauri-apps/api/core";
 import type { GeneratedSessionTitle } from "../sessionTitle";
 import type { PrContent } from "../gitText";
 import { hasLiveCatalog } from "../models";
@@ -131,9 +132,17 @@ export async function sendHarnessTurn(
     throw new Error(`${input.harness} is not connected yet`);
   }
   cancelIdlePark(input.sessionId);
+  const controlled = typeof isTauri === "function" && isTauri();
+  if (controlled)
+    await invoke("control_authorize_turn", {
+      sessionId: input.sessionId,
+      cwd: input.cwd,
+    });
   try {
     await adapter.sendTurn(input);
   } finally {
+    if (controlled)
+      await invoke("control_turn_finished", { sessionId: input.sessionId });
     scheduleIdlePark(input.harness, input.sessionId);
   }
 }
diff --git a/src/lib/harness/types.ts b/src/lib/harness/types.ts
index acf05c26..562372e3 100644
--- a/src/lib/harness/types.ts
+++ b/src/lib/harness/types.ts
@@ -130,6 +130,12 @@ export type HarnessSessionInput = {
   modelSettings?: Record<string, string>;
   runtimeMode: RuntimeMode;
   intent?: TurnIntent;
+  /**
+   * This session drives MonoCode's control CLI, which reaches the app over
+   * loopback. Sandboxes deny network by default, so a lead that cannot open
+   * that socket cannot supervise its agents at all.
+   */
+  controlsAgents?: boolean;
   onEvent: (event: HarnessEvent) => void;
 };
 
diff --git a/src/lib/layout.ts b/src/lib/layout.ts
index 8d56f256..ee909241 100644
--- a/src/lib/layout.ts
+++ b/src/lib/layout.ts
@@ -5,6 +5,7 @@ import {
   defaultTerminalTitle,
   type TerminalMetaPatch,
 } from "./terminalTab";
+import type { HarnessId } from "./session";
 
 /**
  * Split tree for a tab. Same-direction splits share a group so
@@ -42,6 +43,13 @@ export type CommitTabSource = {
   subject: string;
 };
 
+/** One orchestration worker, opened for inspection beside its lead. */
+export type AgentTabSource = {
+  sessionId: string;
+  leadId: string;
+  harness: HarnessId;
+};
+
 export type SessionChangesSource = {
   sessionId: string;
 };
@@ -61,6 +69,8 @@ export type FilePaneTab = {
   sessionChanges?: SessionChangesSource;
   /** Historical commit review (unified diff, read-only). */
   commit?: CommitTabSource;
+  /** Read-only transcript of an orchestration worker. Live only — not persisted. */
+  agent?: AgentTabSource;
   terminal?: boolean;
   /** Foreground command when it isn't the shell. Live only — not persisted. */
   foreground?: string;
@@ -207,6 +217,15 @@ export function newReleaseNotesWorkspaceTab(
   };
 }
 
+/** `path` carries the label: an agent tab has no file behind it. */
+export function newAgentTab(
+  title: string,
+  cwd: string,
+  agent: AgentTabSource,
+): FilePaneTab {
+  return { id: crypto.randomUUID(), path: title, cwd, agent };
+}
+
 export function newTerminalFile(cwd: string, title?: string): FilePaneTab {
   return {
     id: crypto.randomUUID(),
@@ -319,8 +338,19 @@ export function isTerminalTab(file: FilePaneTab): boolean {
   return !!file.terminal;
 }
 
+export function isAgentTab(
+  file: FilePaneTab,
+): file is FilePaneTab & { agent: AgentTabSource } {
+  return !!file.agent;
+}
+
 export function isVirtualDocumentTab(file: FilePaneTab): boolean {
-  return isPlanTab(file) || isReleaseNotesTab(file) || isCommitTab(file);
+  return (
+    isPlanTab(file) ||
+    isReleaseNotesTab(file) ||
+    isCommitTab(file) ||
+    isAgentTab(file)
+  );
 }
 
 export function isFilesystemTab(file: FilePaneTab): boolean {
@@ -399,6 +429,7 @@ export function isSessionChangesTab(
 
 export function editorTabKey(file: FilePaneTab): string {
   if (file.terminal) return `terminal:${file.id}`;
+  if (file.agent) return `agent:${file.agent.sessionId}`;
   if (file.plan) return `plan:${file.plan.blockId}`;
   if (file.releaseNotes) return `release-notes:${file.releaseNotes.version}`;
   if (file.commit) return `commit:${file.cwd}:${file.commit.sha}`;
diff --git a/src/lib/liveAgents.test.ts b/src/lib/liveAgents.test.ts
index cd7beffe..ce3f1790 100644
--- a/src/lib/liveAgents.test.ts
+++ b/src/lib/liveAgents.test.ts
@@ -28,6 +28,11 @@ function edit(id: string, path = "src/App.tsx", status = "in_progress"): Block {
 }
 
 describe("liveAgentsFromSessions", () => {
+  it("keeps internal workers in their lead's agent panel", () => {
+    const lead = chat("/repo", { id: "lead", busy: true });
+    const worker = chat("/repo", { id: "worker", busy: true, orchestrationLeadId: "lead" });
+    expect(liveAgentsFromSessions([lead, worker]).map((agent) => agent.id)).toEqual(["lead"]);
+  });
   it("skips idle sessions", () => {
     expect(liveAgentsFromSessions([chat("/tmp/a")])).toEqual([]);
   });
diff --git a/src/lib/liveAgents.ts b/src/lib/liveAgents.ts
index 8e6350e2..93d77914 100644
--- a/src/lib/liveAgents.ts
+++ b/src/lib/liveAgents.ts
@@ -27,7 +27,7 @@ export function liveAgentsFromSessions(
   return sessions
     .filter(
       (session) =>
-        !session.inboxAsk && (isInFlightSession(session) || unseenFinishedIds.has(session.id)),
+        !session.inboxAsk && !session.orchestrationLeadId && (isInFlightSession(session) || unseenFinishedIds.has(session.id)),
     )
     .map((session) =>
       toLiveAgent(session, unseenFinishedIds.has(session.id)),
diff --git a/src/lib/orchestration.test.ts b/src/lib/orchestration.test.ts
new file mode 100644
index 00000000..2fcd9eb6
--- /dev/null
+++ b/src/lib/orchestration.test.ts
@@ -0,0 +1,792 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import {
+  Orchestrator,
+  scopesOverlap,
+  visibleUserPrompt,
+  workerTurnPrompt,
+  type ControlOutcome,
+  type OrchestrationHost,
+  type OrchestrationRun,
+  shellPath,
+} from "./orchestration";
+import { newSession } from "./session";
+import type { OrchestrationProposal } from "./orchestrationPlan";
+
+function setup() {
+  const saved = new Map<string, OrchestrationRun>();
+  const store = {
+    save: vi.fn(async (run: OrchestrationRun) => {
+      saved.set(run.leadId, structuredClone(run));
+    }),
+    load: vi.fn(async (id: string) => saved.get(id) ?? null),
+    enable: vi.fn(
+      async () => "/Applications/MonoCode.app/Contents/MacOS/monocode",
+    ),
+    disable: vi.fn(async () => {}),
+    scopes: vi.fn(async (_cwd: string, files: string[]) =>
+      files.map((file) => (file === "." ? "/repo" : `/repo/${file}`)),
+    ),
+  };
+  const manager = new Orchestrator(store);
+  const lead = { ...newSession("claude", "/repo"), id: "lead", busy: true };
+  const sessions = [lead];
+  const completions = new Map<string, (outcome: ControlOutcome) => void>();
+  const host: OrchestrationHost = {
+    session: (id) => sessions.find((session) => session.id === id),
+    sessions: () => sessions,
+    choices: () => [
+      { harness: "codex", models: [{ id: "codex:test", name: "Test" }] },
+    ],
+    createWorker: vi.fn(async (run, task) => {
+      sessions.push({
+        ...newSession(task.harness, run.cwd),
+        id: task.sessionId,
+        busy: false,
+      });
+    }),
+    submit: vi.fn((id, _text, done) => {
+      const session = sessions.find((session) => session.id === id)!;
+      session.busy = true;
+      completions.set(id, (outcome) => {
+        session.busy = false;
+        done(outcome);
+      });
+    }),
+    stop: vi.fn(async (id) => {
+      const session = sessions.find((entry) => entry.id === id);
+      if (session) session.busy = false;
+    }),
+    steer: vi.fn(async () => {}),
+    respondApproval: vi.fn(),
+    answerQuestion: vi.fn(),
+  };
+  manager.bind(host);
+  let request = 0;
+  const call = (
+    action: string,
+    input: Record<string, unknown> = {},
+    id = `request-${++request}`,
+  ) => manager.handle("lead", id, action, input);
+  const start = async () => {
+    lead.busy = false;
+    await manager.start("lead", ["codex"], 2);
+    lead.busy = true;
+  };
+  const delegate = (files: string[], extra = {}) =>
+    call("delegate", {
+      title: "Task",
+      prompt: "Implement the bounded change",
+      harness: "codex",
+      files,
+      ...extra,
+    });
+  const tasks = () => manager.run("lead")!.tasks;
+  return {
+    manager,
+    store,
+    host,
+    lead,
+    saved,
+    sessions,
+    start,
+    call,
+    delegate,
+    tasks,
+    completions,
+  };
+}
+
+afterEach(() => {
+  vi.useRealTimers();
+});
+
+describe("worker assignment prompts", () => {
+  it("keeps the task text and wraps it in the assignment envelope", () => {
+    const sent = workerTurnPrompt("Review the branch.", ["src/App.tsx"]);
+    expect(sent.startsWith("Review the branch.")).toBe(true);
+    expect(sent).toContain("<monocode_assignment>");
+    expect(sent).toContain("src/App.tsx");
+    expect(visibleUserPrompt(sent)).toBe("Review the branch.");
+  });
+});
+
+describe("local orchestration", () => {
+  it("stops and forgets a deleted lead without persisting it again", async () => {
+    const f = setup();
+    await f.start();
+    await f.delegate(["src"]);
+    await vi.waitFor(() => expect(f.tasks()[0].status).toBe("running"));
+    const task = f.tasks()[0];
+    const remove = vi.fn(async () => {
+      expect(f.lead.busy).toBe(false);
+      expect(f.manager.run("lead")?.status).toBe("stopped");
+      f.saved.delete("lead");
+    });
+    await f.manager.deleteSession("lead", remove);
+    expect(remove).toHaveBeenCalledOnce();
+    expect(f.host.stop).toHaveBeenCalledWith(task.sessionId);
+    expect(f.manager.snapshot()).toEqual([]);
+    f.store.save.mockClear();
+    f.completions.get(task.sessionId)?.({
+      status: "completed",
+      text: "Late result",
+    });
+    await f.manager.hydrate("lead");
+    f.manager.sync();
+    await Promise.resolve();
+    expect(f.manager.snapshot()).toEqual([]);
+    expect(f.store.save).not.toHaveBeenCalled();
+  });
+
+  it("reloads a deleted worker's pruned run and preserves state if deletion fails", async () => {
+    const f = setup();
+    await f.start();
+    await f.delegate(["src"]);
+    await vi.waitFor(() => expect(f.tasks()[0].status).toBe("running"));
+    const task = f.tasks()[0];
+    await expect(
+      f.manager.deleteSession(task.sessionId, async () => {
+        throw new Error("Delete failed");
+      }),
+    ).rejects.toThrow("Delete failed");
+    expect(f.tasks()).toHaveLength(1);
+    expect(f.manager.run("lead")?.status).toBe("stopped");
+    await f.manager.deleteSession(task.sessionId, async () => {
+      f.saved.set("lead", { ...f.saved.get("lead")!, tasks: [], requests: {} });
+      f.store.save.mockClear();
+    });
+    expect(f.tasks()).toEqual([]);
+    expect(f.manager.forSession(task.sessionId)).toBeUndefined();
+    expect(f.store.save).not.toHaveBeenCalled();
+  });
+
+  const proposal = (): OrchestrationProposal => ({
+    version: 1,
+    leadId: "lead",
+    cwd: "/repo",
+    request: "Build settings",
+    author: { harness: "claude", model: "claude:test", name: "Lead" },
+    settings: {
+      choices: [{ harness: "codex", model: "codex:test", name: "Test" }],
+      maxWorkers: 2,
+    },
+    status: "ready",
+    title: "Settings",
+    summary: "Split the work",
+    tasks: [
+      {
+        id: "ui",
+        title: "UI",
+        prompt: "User edited instructions",
+        harness: "codex",
+        model: "codex:test",
+        files: ["src/ui"],
+        dependsOn: ["types"],
+      },
+      {
+        id: "types",
+        title: "Types",
+        prompt: "Define the types",
+        harness: "codex",
+        model: "codex:test",
+        files: ["src/types"],
+        dependsOn: [],
+      },
+    ],
+  });
+  it("starts exactly the approved assignments and preserves forward dependencies", async () => {
+    const f = setup();
+    f.lead.busy = false;
+    expect(f.host.submit).not.toHaveBeenCalled();
+    await f.manager.startApproved("lead", "card", proposal());
+    await vi.waitFor(() =>
+      expect(f.host.createWorker).toHaveBeenCalledTimes(1),
+    );
+    expect(f.tasks().map((task) => task.status)).toEqual(["queued", "running"]);
+    expect(f.tasks()[0].prompt).toBe("User edited instructions");
+    expect(f.tasks()[0].dependsOn).toEqual([f.tasks()[1].id]);
+    expect(f.manager.run("lead")?.proposalId).toBe("card");
+    expect(f.saved.get("lead")?.tasks).toHaveLength(2);
+    const workerPrompt = vi
+      .mocked(f.host.submit)
+      .mock.calls.find(
+        ([id, prompt]) =>
+          id !== "lead" && String(prompt).includes("<monocode_assignment>"),
+      )?.[1];
+    expect(workerPrompt).toContain("Define the types");
+    expect(workerPrompt).toContain("<monocode_assignment>");
+    expect(
+      vi.mocked(f.host.submit).mock.calls.find(([id]) => id === "lead")?.[1],
+    ).toContain("do not delegate duplicates");
+  });
+  it("never launches a partial plan when one assignment has invalid scopes", async () => {
+    const f = setup();
+    f.lead.busy = false;
+    f.store.scopes.mockRejectedValueOnce(new Error("Scope escapes project"));
+    await expect(
+      f.manager.startApproved("lead", "card", proposal()),
+    ).rejects.toThrow("Scope escapes");
+    expect(f.store.enable).not.toHaveBeenCalled();
+    expect(f.host.submit).not.toHaveBeenCalled();
+  });
+  it("requires a ready proposal and enforces the exact model pool for later CLI calls", async () => {
+    const f = setup();
+    f.lead.busy = false;
+    await expect(
+      f.manager.startApproved("lead", "card", {
+        ...proposal(),
+        status: "planning",
+      }),
+    ).rejects.toThrow("completed proposal");
+    f.host.choices = () => [
+      {
+        harness: "codex",
+        models: [
+          { id: "codex:test", name: "Test" },
+          { id: "codex:extra", name: "Unselected" },
+        ],
+      },
+    ];
+    await f.manager.startApproved("lead", "card", proposal());
+    const result = (await f.call("list")) as {
+      harnesses: { models: { id: string }[] }[];
+    };
+    expect(result.harnesses[0].models.map((model) => model.id)).toEqual([
+      "codex:test",
+    ]);
+    await expect(
+      f.delegate(["extra"], { model: "codex:extra" }),
+    ).rejects.toThrow("model ID returned by list");
+  });
+  it("does not duplicate work when confirmation is repeated", async () => {
+    const f = setup();
+    f.lead.busy = false;
+    const results = await Promise.allSettled([
+      f.manager.startApproved("lead", "card", proposal()),
+      f.manager.startApproved("lead", "card", proposal()),
+    ]);
+    expect(
+      results.filter((result) => result.status === "fulfilled"),
+    ).toHaveLength(1);
+    expect(f.store.enable).toHaveBeenCalledTimes(1);
+    expect(f.tasks()).toHaveLength(2);
+  });
+  it("ignores unavailable unused catalog models but blocks an unavailable assignment", async () => {
+    const f = setup();
+    f.lead.busy = false;
+    const card = proposal();
+    card.settings.choices.push({
+      harness: "claude",
+      model: "claude:removed",
+      name: "Removed",
+    });
+    await f.manager.startApproved("lead", "card", card);
+    expect(f.manager.run("lead")?.allowedHarnesses).toEqual(["codex"]);
+    expect(f.manager.run("lead")?.allowedModels).toEqual(
+      proposal().settings.choices,
+    );
+
+    const unavailable = setup();
+    unavailable.lead.busy = false;
+    card.tasks[0] = {
+      ...card.tasks[0],
+      harness: "claude",
+      model: "claude:removed",
+    };
+    await expect(
+      unavailable.manager.startApproved("lead", "card", card),
+    ).rejects.toThrow("An assigned model is no longer available");
+    expect(unavailable.store.enable).not.toHaveBeenCalled();
+    expect(unavailable.host.submit).not.toHaveBeenCalled();
+  });
+  it("treats directory scopes as overlapping only at path boundaries", () => {
+    expect(scopesOverlap(["/repo/src"], ["/repo/src/file.ts"])).toBe(true);
+    expect(scopesOverlap(["/repo/src"], ["/repo/src2/file.ts"])).toBe(false);
+    expect(scopesOverlap(["/repo"], ["/repo/anything"])).toBe(true);
+  });
+  it("runs disjoint workers concurrently and queues overlap", async () => {
+    const f = setup();
+    await f.start();
+    await f.delegate(["src/a"]);
+    await f.delegate(["src/b"]);
+    await f.delegate(["src/a/file.ts"]);
+    await vi.waitFor(() =>
+      expect(f.tasks().map((task) => task.status)).toEqual([
+        "running",
+        "running",
+        "queued",
+      ]),
+    );
+    expect(f.host.submit).toHaveBeenCalledTimes(2);
+    f.completions.get(f.tasks()[0].sessionId)!({
+      status: "completed",
+      text: "Implemented A",
+    });
+    await vi.waitFor(() => expect(f.tasks()[2].status).toBe("running"));
+    expect(f.tasks()[0].accepted).toBe(false);
+  });
+  it("keeps a dependency queued until the lead accepts the upstream result", async () => {
+    const f = setup();
+    await f.start();
+    await f.delegate(["src/types.ts"]);
+    await vi.waitFor(() => expect(f.host.submit).toHaveBeenCalledTimes(1));
+    const upstream = f.tasks()[0];
+    await f.delegate(["src/ui"], { dependsOn: [upstream.id] });
+    f.completions.get(upstream.sessionId)!({
+      status: "completed",
+      text: "Types ready",
+    });
+    await vi.waitFor(() => expect(f.tasks()[0].status).toBe("completed"));
+    expect(f.tasks()[1].status).toBe("queued");
+    await f.call("review", { taskId: upstream.id });
+    await vi.waitFor(() => expect(f.tasks()[1].status).toBe("running"));
+  });
+  it("deduplicates command retries and rejects foreign tasks or unapproved harnesses", async () => {
+    const f = setup();
+    await f.start();
+    const input = {
+      title: "A",
+      prompt: "Implement",
+      harness: "codex",
+      files: ["a"],
+    };
+    const first = await f.call("delegate", input, "same");
+    expect(await f.call("delegate", input, "same")).toEqual(first);
+    expect(f.tasks()).toHaveLength(1);
+    await expect(
+      f.call("delegate", { ...input, title: "B" }, "same"),
+    ).rejects.toThrow("different input");
+    await expect(f.call("get", { taskId: "foreign" })).rejects.toThrow(
+      "does not belong",
+    );
+    await expect(f.delegate(["a"], { harness: "pi" })).rejects.toThrow(
+      "not allowed",
+    );
+  });
+  it("does not dispatch a worker if its task cannot be persisted", async () => {
+    const f = setup();
+    await f.start();
+    f.store.save.mockRejectedValueOnce(new Error("Disk full"));
+    await expect(f.delegate(["a"])).rejects.toThrow("Disk full");
+    expect(f.manager.run("lead")!.status).toBe("paused");
+    expect(f.host.submit).not.toHaveBeenCalled();
+  });
+  it("persists a delegation and its retry receipt in the same snapshot", async () => {
+    const f = setup();
+    await f.start();
+    const input = {
+      title: "A",
+      prompt: "Implement",
+      harness: "codex",
+      files: ["a"],
+    };
+    await f.call("delegate", input, "durable");
+    const firstTaskSave = f.store.save.mock.calls.find(
+      ([run]) => run.tasks.length === 1,
+    )![0];
+    expect(firstTaskSave.requests.durable.result).toMatchObject({
+      taskId: firstTaskSave.tasks[0].id,
+    });
+    const restored = new Orchestrator(f.store);
+    restored.bind(f.host);
+    await restored.hydrate("lead");
+    expect(await restored.handle("lead", "durable", "delegate", input)).toEqual(
+      firstTaskSave.requests.durable.result,
+    );
+    expect(restored.run("lead")!.tasks).toHaveLength(1);
+  });
+  it("rejects conflicting reuse of an in-flight request ID", async () => {
+    const f = setup();
+    await f.start();
+    let release!: (paths: string[]) => void;
+    f.store.scopes.mockImplementationOnce(
+      () =>
+        new Promise((resolve) => {
+          release = resolve;
+        }),
+    );
+    const input = {
+      title: "A",
+      prompt: "Implement",
+      harness: "codex",
+      files: ["a"],
+    };
+    const pending = f.call("delegate", input, "pending");
+    await vi.waitFor(() => expect(f.store.scopes).toHaveBeenCalled());
+    await expect(
+      f.call("delegate", { ...input, files: ["b"] }, "pending"),
+    ).rejects.toThrow("different input");
+    release(["/repo/a"]);
+    await pending;
+    expect(f.tasks()).toHaveLength(1);
+  });
+  it("stops an active worker if saving another assignment fails", async () => {
+    const f = setup();
+    await f.start();
+    await f.delegate(["a"]);
+    await vi.waitFor(() => expect(f.host.submit).toHaveBeenCalledTimes(1));
+    f.store.save.mockRejectedValueOnce(new Error("Disk full"));
+    await expect(f.delegate(["b"])).rejects.toThrow("Disk full");
+    expect(f.host.stop).toHaveBeenCalledWith(f.tasks()[0].sessionId);
+    expect(f.manager.run("lead")!.status).toBe("paused");
+    expect(f.host.submit).toHaveBeenCalledTimes(1);
+  });
+  it("pauses and stops workers when a reported write escapes its scope", async () => {
+    const f = setup();
+    await f.start();
+    await f.delegate(["src/a"]);
+    await vi.waitFor(() => expect(f.host.submit).toHaveBeenCalledTimes(1));
+    f.manager.observe(f.tasks()[0].sessionId, {
+      type: "tool.started",
+      callId: "edit",
+      title: "Edit",
+      preview: { kind: "write", path: "src/a/../b/file.ts" },
+    });
+    await vi.waitFor(() => expect(f.tasks()[0].status).toBe("cancelled"));
+    expect(f.manager.run("lead")!.status).toBe("paused");
+    expect(f.manager.run("lead")!.error).toContain("outside its assignment");
+  });
+  it("holds ownership until a cancelled process has stopped", async () => {
+    const f = setup();
+    await f.start();
+    await f.delegate(["a"]);
+    await f.delegate(["a"]);
+    await vi.waitFor(() => expect(f.host.submit).toHaveBeenCalledTimes(1));
+    let stopped!: () => void;
+    vi.mocked(f.host.stop).mockImplementationOnce(
+      () =>
+        new Promise<void>((resolve) => {
+          stopped = resolve;
+        }),
+    );
+    const cancel = f.call("cancel", { taskId: f.tasks()[0].id });
+    await vi.waitFor(() => expect(f.tasks()[0].status).toBe("cancelling"));
+    expect(f.tasks()[1].status).toBe("queued");
+    stopped();
+    await cancel;
+    await vi.waitFor(() => expect(f.tasks()[1].status).toBe("running"));
+  });
+  it("stops queued work and suppresses lead continuation on stop", async () => {
+    const f = setup();
+    await f.start();
+    await f.delegate(["a"]);
+    await f.delegate(["a"]);
+    await vi.waitFor(() => expect(f.host.submit).toHaveBeenCalledTimes(1));
+    const done = f.completions.get(f.tasks()[0].sessionId)!;
+    await f.manager.stopRun("lead");
+    done({ status: "completed", text: "late output" });
+    f.lead.busy = false;
+    f.manager.sync();
+    expect(f.tasks().map((task) => task.status)).toEqual([
+      "cancelled",
+      "cancelled",
+    ]);
+    expect(f.manager.run("lead")!.status).toBe("stopped");
+    expect(f.store.disable).toHaveBeenCalledWith("lead");
+    expect(f.host.submit).toHaveBeenCalledTimes(1);
+  });
+  it("returns worker output to an idle lead once", async () => {
+    const f = setup();
+    await f.start();
+    await f.delegate(["a"]);
+    await vi.waitFor(() => expect(f.host.submit).toHaveBeenCalledTimes(1));
+    f.lead.busy = false;
+    f.completions.get(f.tasks()[0].sessionId)!({
+      status: "completed",
+      text: "Tests pass",
+    });
+    await vi.waitFor(() => expect(f.host.submit).toHaveBeenCalledTimes(2));
+    expect(vi.mocked(f.host.submit).mock.calls[1][0]).toBe("lead");
+    expect(vi.mocked(f.host.submit).mock.calls[1][1]).toContain("Tests pass");
+    f.manager.sync();
+    expect(f.host.submit).toHaveBeenCalledTimes(2);
+  });
+  it("keeps results available and pauses when the lead cannot continue", async () => {
+    const f = setup();
+    await f.start();
+    await f.delegate(["a"]);
+    await vi.waitFor(() => expect(f.host.submit).toHaveBeenCalledTimes(1));
+    f.lead.busy = false;
+    f.completions.get(f.tasks()[0].sessionId)!({
+      status: "completed",
+      text: "Result",
+    });
+    await vi.waitFor(() => expect(f.host.submit).toHaveBeenCalledTimes(2));
+    f.completions.get("lead")!({
+      status: "failed",
+      text: "",
+      error: "Provider unavailable",
+    });
+    await vi.waitFor(() =>
+      expect(f.manager.run("lead")!.status).toBe("paused"),
+    );
+    expect(f.tasks()[0].delivered).toBe(false);
+    f.manager.sync();
+    expect(f.host.submit).toHaveBeenCalledTimes(2);
+  });
+  it("recovers interrupted tasks as failed instead of re-executing edits", async () => {
+    const f = setup();
+    await f.start();
+    await f.delegate(["a"]);
+    await vi.waitFor(() => expect(f.tasks()[0].status).toBe("running"));
+    await vi.waitFor(() =>
+      expect(f.saved.get("lead")?.tasks[0].status).toBe("running"),
+    );
+    const restored = new Orchestrator(f.store);
+    restored.bind(f.host);
+    await restored.hydrate("lead");
+    expect(restored.run("lead")?.status).toBe("paused");
+    expect(restored.run("lead")?.tasks[0].status).toBe("failed");
+    expect(f.host.submit).toHaveBeenCalledTimes(1);
+  });
+  it("does not claim a turn or run is successful before review", async () => {
+    const f = setup();
+    await f.start();
+    await f.delegate(["a"]);
+    await expect(f.call("finish")).rejects.toThrow("Review all");
+    await vi.waitFor(() => expect(f.host.submit).toHaveBeenCalledTimes(1));
+    f.completions.get(f.tasks()[0].sessionId)!({
+      status: "failed",
+      text: "Partial edits",
+      error: "Provider crashed",
+    });
+    await vi.waitFor(() => expect(f.tasks()[0].status).toBe("failed"));
+    await expect(f.call("review", { taskId: f.tasks()[0].id })).rejects.toThrow(
+      "Only a completed",
+    );
+  });
+  it("names the way out of a run that cannot finish yet", async () => {
+    const f = setup();
+    await f.start();
+    await f.delegate(["a"]);
+    await vi.waitFor(() => expect(f.host.submit).toHaveBeenCalledTimes(1));
+    f.completions.get(f.tasks()[0].sessionId)!({
+      status: "failed",
+      text: "",
+      error: "Provider crashed",
+    });
+    await vi.waitFor(() => expect(f.tasks()[0].status).toBe("failed"));
+    // A failed task can never be reviewed, so both exits must be spelled out.
+    await expect(f.call("review", { taskId: f.tasks()[0].id })).rejects.toThrow(
+      /message.*cancel/,
+    );
+    await expect(f.call("finish")).rejects.toThrow(/Task \(failed\)/);
+    await expect(f.call("finish")).rejects.toThrow(/message.*cancel/);
+    await f.call("cancel", { taskId: f.tasks()[0].id });
+    expect(await f.call("finish")).toEqual({ finished: true });
+  });
+  it("rejects mistyped fields instead of silently dropping them", async () => {
+    const f = setup();
+    await f.start();
+    // Silently ignoring depends_on would race two workers over one file.
+    await expect(
+      f.delegate(["a"], { depends_on: [], modelId: "codex:test" }),
+    ).rejects.toThrow("Unknown delegate fields: depends_on, modelId");
+    await expect(f.call("finish", { taskId: "x" })).rejects.toThrow(
+      "finish takes no input",
+    );
+    await expect(f.call("wait", { timeout: 5 })).rejects.toThrow(
+      "wait accepts: timeoutSeconds",
+    );
+    expect(f.tasks()).toHaveLength(0);
+  });
+  it("points a bad delegate at the values list would have returned", async () => {
+    const f = setup();
+    await f.start();
+    await expect(f.delegate(["a"], { harness: "claude" })).rejects.toThrow(
+      'Harness "claude" is not allowed in this run. Allowed: codex.',
+    );
+    await expect(f.delegate(["a"], { model: "codex:ghost" })).rejects.toThrow(
+      "Choose a model ID returned by list for codex: codex:test.",
+    );
+    await expect(f.delegate([], {})).rejects.toThrow("at least one file");
+    await expect(
+      f.call("delegate", {
+        title: "T",
+        prompt: "P",
+        harness: "codex",
+        files: ["a"],
+        dependsOn: ["nope"],
+      }),
+    ).rejects.toThrow("unknown or cancelled: nope");
+  });
+  it("keeps the retry ledger free of inherited object keys", async () => {
+    const f = setup();
+    await f.start();
+    const first = await f.call(
+      "delegate",
+      {
+        title: "A",
+        prompt: "Implement",
+        harness: "codex",
+        files: ["a"],
+      },
+      "constructor",
+    );
+    expect(first).toHaveProperty("taskId");
+  });
+  it("quotes the control path only when the shell needs it", () => {
+    expect(
+      shellPath("/Applications/MonoCode.app/Contents/MacOS/monocode"),
+    ).toBe("/Applications/MonoCode.app/Contents/MacOS/monocode");
+    expect(shellPath("/Users/a b/MonoCode")).toBe("'/Users/a b/MonoCode'");
+    expect(shellPath("C:/Program Files/MonoCode/monocode.exe")).toBe(
+      '"C:/Program Files/MonoCode/monocode.exe"',
+    );
+    expect(shellPath("C:\\Tools\\monocode.exe")).toBe("C:\\Tools\\monocode.exe");
+    // A backslash escapes in a POSIX shell, so bare would rewrite the path.
+    expect(shellPath("/Users/a\\b/MonoCode")).toBe("'/Users/a\\b/MonoCode'");
+    expect(shellPath("/Users/it's/MonoCode")).toBe("'/Users/it'\\''s/MonoCode'");
+  });
+  it("treats an action named after an Object member as unknown", async () => {
+    const f = setup();
+    await f.start();
+    for (const action of ["constructor", "toString", "__proto__"])
+      await expect(f.call(action)).rejects.toThrow(
+        `Unknown action "${action}"`,
+      );
+  });
+  it("routes a blocked agent to the lead instead of the user", async () => {
+    const f = setup();
+    await f.start();
+    await f.delegate(["a"]);
+    await vi.waitFor(() => expect(f.host.submit).toHaveBeenCalledTimes(1));
+    const worker = f.sessions.find(
+      (session) => session.id === f.tasks()[0].sessionId,
+    )!;
+    worker.blocks = [
+      {
+        id: "ask",
+        role: "approval",
+        text: "rm -rf build",
+        approval: { requestId: 7 },
+      },
+    ];
+    const view = (await f.call("get", { taskId: f.tasks()[0].id })) as {
+      needsInput?: { kind: string; requestId: number };
+    };
+    expect(view.needsInput).toMatchObject({ kind: "approval", requestId: 7 });
+    // A stale or invented requestId must never decide a live prompt.
+    await expect(
+      f.call("respond", {
+        taskId: f.tasks()[0].id,
+        requestId: 6,
+        decision: "allow",
+      }),
+    ).rejects.toThrow("Stale requestId");
+    await expect(
+      f.call("respond", {
+        taskId: f.tasks()[0].id,
+        requestId: 7,
+        decision: "maybe",
+      }),
+    ).rejects.toThrow('decision must be "allow" or "deny"');
+    await f.call("respond", {
+      taskId: f.tasks()[0].id,
+      requestId: 7,
+      decision: "deny",
+    });
+    expect(f.host.respondApproval).toHaveBeenCalledWith(
+      worker.id,
+      7,
+      "deny",
+    );
+  });
+  it("validates the lead's answer against the agent's own question", async () => {
+    const f = setup();
+    await f.start();
+    await f.delegate(["a"]);
+    await vi.waitFor(() => expect(f.host.submit).toHaveBeenCalledTimes(1));
+    const worker = f.sessions.find(
+      (session) => session.id === f.tasks()[0].sessionId,
+    )!;
+    worker.pendingQuestion = {
+      requestId: 9,
+      title: "Pick a check",
+      questions: [
+        {
+          id: "check",
+          prompt: "Which check?",
+          multiSelect: false,
+          allowCustom: false,
+          options: [{ id: "unit", label: "Unit" }],
+        },
+      ],
+    };
+    const taskId = f.tasks()[0].id;
+    await expect(
+      f.call("answer", { taskId, requestId: 9, answers: { check: ["e2e"] } }),
+    ).rejects.toThrow("Unknown option");
+    await expect(
+      f.call("answer", { taskId, requestId: 9, answers: { nope: ["unit"] } }),
+    ).rejects.toThrow("Unknown question");
+    await f.call("answer", { taskId, requestId: 9, answers: { check: ["unit"] } });
+    expect(f.host.answerQuestion).toHaveBeenCalledWith(worker.id, 9, {
+      kind: "answered",
+      answers: { check: ["unit"] },
+    });
+  });
+  it("stops the agents whenever the lead stops supervising", async () => {
+    const f = setup();
+    f.lead.busy = false;
+    await f.manager.startApproved("lead", "card", proposal());
+    await vi.waitFor(() =>
+      expect(f.host.createWorker).toHaveBeenCalledTimes(1),
+    );
+    const running = f.tasks().find((task) => task.title === "Types")!;
+    expect(running.status).toBe("running");
+    // The lead's turn dies. Its agents must not carry on editing the shared
+    // checkout with nobody left to review them.
+    f.completions.get("lead")!({
+      status: "failed",
+      text: "",
+      error: "Provider crashed",
+    });
+    await vi.waitFor(() => expect(f.manager.run("lead")!.status).toBe("paused"));
+    await vi.waitFor(() =>
+      expect(
+        f.tasks().find((task) => task.title === "Types")!.status,
+      ).toBe("cancelled"),
+    );
+    expect(f.host.stop).toHaveBeenCalledWith(running.sessionId);
+    // Queued work is untouched, so resuming picks it up intact.
+    expect(f.tasks().find((task) => task.title === "UI")!.status).toBe(
+      "queued",
+    );
+  });
+  it("steers a running agent and refuses one that is not", async () => {
+    const f = setup();
+    await f.start();
+    await f.delegate(["a"]);
+    await vi.waitFor(() => expect(f.tasks()[0].status).toBe("running"));
+    const task = f.tasks()[0];
+    await f.call("steer", { taskId: task.id, text: "Use the existing helper" });
+    expect(f.host.steer).toHaveBeenCalledWith(
+      task.sessionId,
+      "Use the existing helper",
+    );
+    // Steering must not end the turn, so the agent keeps its work.
+    expect(f.tasks()[0].status).toBe("running");
+    expect(f.host.stop).not.toHaveBeenCalledWith(task.sessionId);
+    // A stopped agent takes a fresh turn instead, and the error says so.
+    f.completions.get(task.sessionId)!({
+      status: "completed",
+      text: "Done",
+    });
+    await vi.waitFor(() => expect(f.tasks()[0].status).toBe("completed"));
+    await expect(
+      f.call("steer", { taskId: task.id, text: "Too late" }),
+    ).rejects.toThrow(/Only a running agent can be steered.*message/s);
+  });
+  it("blocks ordinary sessions while a run owns their checkout", async () => {
+    const f = setup();
+    await f.start();
+    f.sessions.push({
+      ...newSession("claude", "/repo"),
+      id: "other",
+      busy: false,
+    });
+    expect(f.manager.submissionError("other")).toContain("active orchestrator");
+    expect(f.manager.submissionError("lead")).toBeNull();
+  });
+});
diff --git a/src/lib/orchestration.ts b/src/lib/orchestration.ts
new file mode 100644
index 00000000..5d10dc07
--- /dev/null
+++ b/src/lib/orchestration.ts
@@ -0,0 +1,1391 @@
+import { invoke } from "@tauri-apps/api/core";
+import { HARNESSES, type HarnessId, type Session } from "./session";
+import type { ApprovalDecision, HarnessEvent } from "./harness/types";
+import { pendingApprovalForSession } from "./approvalToast";
+import type { UserQuestionReply } from "./userQuestion";
+import {
+  validateOrchestrationSettings,
+  validateProposedTasks,
+  type OrchestrationChoice,
+  type OrchestrationProposal,
+} from "./orchestrationPlan";
+
+export type TaskStatus =
+  "queued" | "running" | "cancelling" | "completed" | "failed" | "cancelled";
+export type OrchestrationTask = {
+  id: string;
+  assignmentId?: string;
+  sessionId: string;
+  title: string;
+  harness: HarnessId;
+  model: string;
+  prompt: string;
+  files: string[];
+  scopes: string[];
+  dependsOn: string[];
+  status: TaskStatus;
+  accepted: boolean;
+  result: string;
+  error?: string;
+  delivered: boolean;
+};
+export type OrchestrationRun = {
+  version: 1;
+  leadId: string;
+  cwd: string;
+  canonicalRoot?: string;
+  status: "active" | "paused" | "stopped" | "finished";
+  allowedHarnesses: HarnessId[];
+  allowedModels?: OrchestrationChoice[];
+  proposalId?: string;
+  maxWorkers: number;
+  cli: string;
+  tasks: OrchestrationTask[];
+  error?: string;
+  continuations: number;
+  requests: Record<string, { signature: string; result: unknown }>;
+};
+export type ControlOutcome = {
+  status: "completed" | "failed" | "cancelled";
+  text: string;
+  error?: string;
+};
+export type OrchestrationHost = {
+  session(id: string): Session | undefined;
+  sessions(): Session[];
+  choices(): { harness: HarnessId; models: { id: string; name: string }[] }[];
+  createWorker(run: OrchestrationRun, task: OrchestrationTask): Promise<void>;
+  submit(
+    id: string,
+    text: string,
+    done: (outcome: ControlOutcome) => void,
+  ): void;
+  stop(id: string): Promise<void>;
+  /** Redirect a worker mid-turn, without discarding what it has already done. */
+  steer(id: string, text: string): Promise<void>;
+  /** Answer on a worker's behalf; the lead, not the user, decides. */
+  respondApproval(
+    id: string,
+    requestId: number,
+    decision: ApprovalDecision,
+  ): void;
+  answerQuestion(id: string, requestId: number, reply: UserQuestionReply): void;
+};
+type Storage = {
+  save(run: OrchestrationRun): Promise<void>;
+  load(id: string): Promise<OrchestrationRun | null>;
+  enable(id: string, cwd: string): Promise<string>;
+  disable(id: string): Promise<void>;
+  scopes(cwd: string, files: string[]): Promise<string[]>;
+};
+const storage: Storage = {
+  save: (run) =>
+    invoke("control_save", { leadId: run.leadId, state: JSON.stringify(run) }),
+  load: async (id) => {
+    const raw = await invoke<string | null>("control_load", { leadId: id });
+    if (!raw) return null;
+    const run = JSON.parse(raw) as OrchestrationRun;
+    if (run.version !== 1 || run.leadId !== id || !Array.isArray(run.tasks))
+      throw new Error("Unsupported orchestration history");
+    return run;
+  },
+  enable: (sessionId, cwd) => invoke("control_enable", { sessionId, cwd }),
+  disable: (sessionId) => invoke("control_disable", { sessionId }),
+  scopes: (cwd, files) => invoke("control_scopes", { cwd, files }),
+};
+
+export function scopesOverlap(a: string[], b: string[]): boolean {
+  return a.some((left) =>
+    b.some(
+      (right) =>
+        left === right ||
+        left.startsWith(`${right}/`) ||
+        right.startsWith(`${left}/`),
+    ),
+  );
+}
+const activeTask = (task: OrchestrationTask) =>
+  task.status === "running" || task.status === "cancelling";
+export const sameCheckout = (a: string, b: string) =>
+  a.replace(/\\/g, "/").replace(/\/$/, "").toLowerCase() ===
+  b.replace(/\\/g, "/").replace(/\/$/, "").toLowerCase();
+const messageOf = (error: unknown) =>
+  error instanceof Error ? error.message : String(error);
+
+const ASSIGNMENT_BLOCK =
+  /(?:\r?\n[ \t]*)*<monocode_assignment\b[^>]*>[\s\S]*?<\/monocode_assignment>/gi;
+
+/** Prompt the worker receives, including the envelope the transcript hides. */
+export function workerTurnPrompt(prompt: string, files: string[]): string {
+  return `${prompt}\n\n<monocode_assignment>\nYou are a worker managed by a MonoCode lead. Work in this shared checkout. Your assigned write scope is: ${files.join(", ")}. Read other files as needed, but do not edit outside your scope. If another file or shared operation is needed, report the blocker and stop so the lead can assign a new task. Do not spawn agents, create worktrees, switch branches, stage/commit changes, install dependencies or run broad formatters/generators unless this task owns '.' and explicitly requires that operation. Do not undo another agent's changes. Other workers may be editing concurrently; report focused checks, changed files, remaining issues and a concise final result.\n</monocode_assignment>`;
+}
+
+/** Task text a person should see: the assignment envelope stays in the send. */
+export function visibleUserPrompt(text: string): string {
+  return text.replace(ASSIGNMENT_BLOCK, "").trimEnd();
+}
+
+function text(value: unknown, label: string, max = 30_000): string {
+  if (typeof value !== "string" || !value.trim())
+    throw new Error(`Invalid ${label}: provide a non-empty string`);
+  if (value.length > max)
+    throw new Error(`Invalid ${label}: keep it under ${max} characters`);
+  return value.trim();
+}
+function strings(value: unknown, label: string, max = 64): string[] {
+  if (!Array.isArray(value))
+    throw new Error(`Invalid ${label}: provide an array of strings`);
+  if (value.length > max)
+    throw new Error(`Invalid ${label}: at most ${max} entries`);
+  return [...new Set(value.map((item) => text(item, label, 512)))];
+}
+/**
+ * A mistyped field must fail loudly rather than silently change the task. A
+ * Map, so an action named after an Object member is still just unknown.
+ */
+const FIELDS = new Map<string, string[]>([
+  ["list", []],
+  ["delegate", ["title", "harness", "model", "prompt", "files", "dependsOn"]],
+  ["get", ["taskId"]],
+  ["message", ["taskId", "text"]],
+  ["cancel", ["taskId"]],
+  ["wait", ["timeoutSeconds"]],
+  ["review", ["taskId"]],
+  ["finish", []],
+  ["steer", ["taskId", "text"]],
+  ["respond", ["taskId", "requestId", "decision"]],
+  ["answer", ["taskId", "requestId", "answers", "skip"]],
+]);
+function checkFields(action: string, input: Record<string, unknown>) {
+  const allowed = FIELDS.get(action);
+  if (!allowed)
+    throw new Error(
+      `Unknown action "${action}". Use one of: ${[...FIELDS.keys()].join(", ")}. Run the control CLI with --help.`,
+    );
+  const unknown = Object.keys(input).filter((key) => !allowed.includes(key));
+  if (unknown.length)
+    throw new Error(
+      `Unknown ${action} field${unknown.length > 1 ? "s" : ""}: ${unknown.join(", ")}. ${allowed.length ? `${action} accepts: ${allowed.join(", ")}.` : `${action} takes no input.`}`,
+    );
+}
+/**
+ * Quote the executable for the shell the lead runs in, and only when needed.
+ * The path is absolute, so a leading slash means a POSIX shell — where a
+ * backslash escapes rather than separates, and so is never safe bare.
+ */
+export function shellPath(path: string): string {
+  if (path.startsWith("/"))
+    return /^[A-Za-z0-9._/:-]+$/.test(path)
+      ? path
+      : `'${path.replace(/'/g, `'\\''`)}'`;
+  return /[\s"]/.test(path) ? `"${path.replace(/"/g, "")}"` : path;
+}
+/** Map the lead's chosen option IDs onto the worker's own question shape. */
+function questionAnswers(
+  value: unknown,
+  questions: { id: string; options: { id: string }[] }[] = [],
+): Record<string, string[]> {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error(
+      'answers must be an object of questionId -> [optionId], or pass {"skip":true}',
+    );
+  const answers: Record<string, string[]> = {};
+  for (const [id, chosen] of Object.entries(value)) {
+    const question = questions.find((entry) => entry.id === id);
+    if (!question)
+      throw new Error(
+        `Unknown question "${id}". Ask for: ${listed(questions.map((entry) => entry.id)) || "none"}.`,
+      );
+    const ids = strings(chosen, `answers.${id}`, 16);
+    const unknown = ids.filter(
+      (option) => !question.options.some((entry) => entry.id === option),
+    );
+    if (unknown.length)
+      throw new Error(
+        `Unknown option${unknown.length > 1 ? "s" : ""} for "${id}": ${listed(unknown)}. Choose from: ${listed(question.options.map((entry) => entry.id))}.`,
+      );
+    answers[id] = ids;
+  }
+  if (!Object.keys(answers).length)
+    throw new Error('Answer at least one question, or pass {"skip":true}');
+  return answers;
+}
+const listed = (values: string[], max = 12) =>
+  values.length > max
+    ? `${values.slice(0, max).join(", ")} (+${values.length - max} more)`
+    : values.join(", ");
+
+export class Orchestrator {
+  private runs: OrchestrationRun[] = [];
+  private listeners = new Set<() => void>();
+  private loaded = new Set<string>();
+  private deleted = new Set<string>();
+  private persisted = new Map<string, OrchestrationRun>();
+  private saves = Promise.resolve();
+  private actions = Promise.resolve();
+  private pumping = false;
+  private starting = new Set<string>();
+  private pumpAgain = false;
+  private waking = new Set<string>();
+  private blocked = new Map<string, string>();
+  private announced = new Map<string, Set<string>>();
+  private inflight = new Map<
+    string,
+    { signature: string; promise: Promise<unknown> }
+  >();
+  private host: OrchestrationHost | null = null;
+  constructor(private readonly store: Storage = storage) {}
+  bind(host: OrchestrationHost) {
+    this.host = host;
+  }
+  subscribe = (listener: () => void) => {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  };
+  snapshot = () => this.runs;
+  run(id: string) {
+    return this.runs.find((run) => run.leadId === id);
+  }
+  forSession(id: string) {
+    return this.runs.find(
+      (run) =>
+        run.leadId === id || run.tasks.some((task) => task.sessionId === id),
+    );
+  }
+  private emit() {
+    for (const listener of this.listeners) listener();
+  }
+  private async commit(run: OrchestrationRun) {
+    this.runs = [
+      ...this.runs.filter((entry) => entry.leadId !== run.leadId),
+      run,
+    ];
+    this.emit();
+    const saved = this.saves
+      .catch(() => undefined)
+      .then(async () => {
+        await this.store.save(run);
+        this.persisted.set(run.leadId, run);
+      });
+    this.saves = saved;
+    try {
+      await saved;
+    } catch (error) {
+      const current = this.run(run.leadId)!;
+      const running = current.tasks.filter(activeTask);
+      this.runs = this.runs.map((entry) =>
+        entry.leadId === run.leadId
+          ? {
+              ...entry,
+              status: "paused",
+              error: `Could not save run: ${messageOf(error)}`,
+              tasks: entry.tasks.map((task) =>
+                activeTask(task) ? { ...task, status: "cancelling" } : task,
+              ),
+            }
+          : entry,
+      );
+      this.emit();
+      // Keep the checkout reserved until processes have stopped, even if the
+      // database is unavailable. Recovery never repeats an interrupted turn.
+      await Promise.allSettled(
+        [run.leadId, ...running.map((task) => task.sessionId)].map(
+          async (id) => {
+            await this.host?.stop(id);
+            const latest = this.run(run.leadId)!;
+            this.runs = this.runs.map((entry) =>
+              entry.leadId === run.leadId
+                ? {
+                    ...latest,
+                    tasks: latest.tasks.map((task) =>
+                      task.sessionId === id && activeTask(task)
+                        ? {
+                            ...task,
+                            status: "failed",
+                            accepted: false,
+                            delivered: true,
+                            error:
+                              "Stopped because run history could not be saved. Review files before retrying.",
+                          }
+                        : task,
+                    ),
+                  }
+                : entry,
+            );
+            this.emit();
+          },
+        ),
+      );
+      throw error;
+    }
+  }
+  private async patchTask(
+    leadId: string,
+    id: string,
+    patch: Partial<OrchestrationTask>,
+  ) {
+    const run = this.run(leadId);
+    if (run)
+      await this.commit({
+        ...run,
+        tasks: run.tasks.map((task) =>
+          task.id === id ? { ...task, ...patch } : task,
+        ),
+      });
+  }
+  async hydrate(id: string) {
+    if (this.loaded.has(id) || this.run(id)) return;
+    this.loaded.add(id);
+    try {
+      const run = await this.store.load(id);
+      if (!run || this.run(id) || this.deleted.has(id)) return;
+      if (run.status === "active" || run.tasks.some(activeTask)) {
+        await Promise.all(
+          [
+            id,
+            ...run.tasks.filter(activeTask).map((task) => task.sessionId),
+          ].map((sessionId) => this.host?.stop(sessionId)),
+        );
+        await this.store.disable(id);
+      }
+      await this.commit({
+        ...run,
+        status: run.status === "active" ? "paused" : run.status,
+        tasks: run.tasks.map((task) =>
+          activeTask(task)
+            ? {
+                ...task,
+                status: "failed",
+                accepted: false,
+                error: "Interrupted. Review the shared files before retrying.",
+                delivered: false,
+              }
+            : { ...task, delivered: task.accepted || task.status === "queued" },
+        ),
+        error:
+          run.status === "active"
+            ? "Run interrupted. Review the files, then resume."
+            : run.error,
+      });
+    } catch (error) {
+      this.loaded.delete(id);
+      throw error;
+    }
+  }
+  async start(
+    leadId: string,
+    allowedHarnesses: HarnessId[],
+    maxWorkers: number,
+    approved?: {
+      proposalId: string;
+      allowedModels: OrchestrationChoice[];
+      tasks: OrchestrationTask[];
+    },
+  ) {
+    if (this.starting.has(leadId))
+      throw new Error("The run is already starting");
+    this.starting.add(leadId);
+    try {
+      await this.startRun(leadId, allowedHarnesses, maxWorkers, approved);
+    } finally {
+      this.starting.delete(leadId);
+    }
+  }
+  async startApproved(
+    leadId: string,
+    proposalId: string,
+    proposal: OrchestrationProposal,
+  ) {
+    if (proposal.status !== "ready")
+      throw new Error("Review a completed proposal before starting");
+    const settings = validateOrchestrationSettings(proposal.settings);
+    const planned = validateProposedTasks(proposal.tasks, settings);
+    const lead = this.host?.session(leadId);
+    if (!lead || !sameCheckout(lead.cwd, proposal.cwd))
+      throw new Error("Return to the proposal's project before starting");
+    const available = this.host!.choices();
+    const allowedModels = settings.choices.filter((choice) =>
+      available.some(
+        (entry) =>
+          entry.harness === choice.harness &&
+          entry.models.some((model) => model.id === choice.model),
+      ),
+    );
+    if (
+      planned.some(
+        (task) =>
+          !allowedModels.some(
+            (choice) =>
+              choice.harness === task.harness && choice.model === task.model,
+          ),
+      )
+    )
+      throw new Error(
+        "An assigned model is no longer available. Change that assignment before starting.",
+      );
+    const ids = new Map(planned.map((task) => [task.id, crypto.randomUUID()]));
+    const tasks: OrchestrationTask[] = await Promise.all(
+      planned.map(async (task) => ({
+        ...task,
+        id: ids.get(task.id)!,
+        assignmentId: task.id,
+        sessionId: crypto.randomUUID(),
+        scopes: await this.store.scopes(lead.cwd, task.files),
+        dependsOn: task.dependsOn.map((id) => ids.get(id)!),
+        status: "queued",
+        accepted: false,
+        delivered: true,
+        result: "",
+      })),
+    );
+    await this.start(
+      leadId,
+      [...new Set(allowedModels.map((choice) => choice.harness))],
+      settings.maxWorkers,
+      { proposalId, allowedModels, tasks },
+    );
+    this.host!.submit(
+      leadId,
+      `The user confirmed the orchestration card, including any edits. The app has already queued the exact assignments below; do not delegate duplicates. Supervise them through the control CLI, review their changes, request corrections when needed, and finish the original request.\n\nOriginal request:\n${proposal.request}\n\nApproved assignments:\n${JSON.stringify(tasks.map(({ id, title, prompt, harness, model, files, dependsOn }) => ({ taskId: id, title, prompt, harness, model, files, dependsOn })))}`,
+      (outcome) => {
+        if (outcome.status !== "completed")
+          void this.pause(
+            leadId,
+            outcome.error ??
+              "The lead was interrupted. Its agents were stopped; review and resume the run.",
+          ).catch(console.error);
+      },
+    );
+  }
+  private async startRun(
+    leadId: string,
+    allowedHarnesses: HarnessId[],
+    maxWorkers: number,
+    approved?: {
+      proposalId: string;
+      allowedModels: OrchestrationChoice[];
+      tasks: OrchestrationTask[];
+    },
+  ) {
+    const lead = this.host?.session(leadId);
+    if (!lead || lead.busy)
+      throw new Error("Wait for the lead's current turn to finish");
+    if (lead.worktreeCwd)
+      throw new Error(
+        "Start orchestration in a regular project session; this session uses a worktree",
+      );
+    if (!Number.isInteger(maxWorkers) || maxWorkers < 1 || maxWorkers > 4)
+      throw new Error("Choose 1 to 4 workers");
+    const available = this.host!.choices().map((choice) => choice.harness);
+    if (
+      !allowedHarnesses.length ||
+      allowedHarnesses.some((id) => !available.includes(id))
+    )
+      throw new Error("Choose installed worker harnesses");
+    if (
+      this.host!.sessions().some(
+        (session) =>
+          session.id !== leadId &&
+          session.busy &&
+          sameCheckout(session.worktreeCwd ?? session.cwd, lead.cwd),
+      )
+    )
+      throw new Error("Stop other running sessions in this checkout first");
+    const previous = this.run(leadId);
+    if (
+      previous?.status === "active" ||
+      (approved && previous?.status === "paused")
+    )
+      throw new Error("Stop the current run before starting another proposal");
+    if (previous?.tasks.some(activeTask))
+      throw new Error("Stop active workers before changing the run");
+    const [canonicalRoot] = await this.store.scopes(lead.cwd, ["."]);
+    const cli = await this.store.enable(leadId, lead.cwd);
+    try {
+      await this.host!.stop(leadId); // Refresh the child environment before its next turn.
+      await this.commit({
+        version: 1,
+        leadId,
+        cwd: lead.cwd,
+        canonicalRoot,
+        cli,
+        status: "active",
+        allowedHarnesses: [...new Set(allowedHarnesses)],
+        allowedModels:
+          approved?.allowedModels ??
+          (previous?.status === "paused" ? previous.allowedModels : undefined),
+        proposalId:
+          approved?.proposalId ??
+          (previous?.status === "paused" ? previous.proposalId : undefined),
+        maxWorkers,
+        tasks:
+          approved?.tasks ??
+          (previous?.status === "paused" ? previous.tasks : []),
+        continuations: 0,
+        requests: previous?.status === "paused" ? previous.requests : {},
+      });
+    } catch (error) {
+      await this.store.disable(leadId);
+      throw error;
+    }
+    void this.pump();
+    this.sync();
+  }
+  submissionError(id: string, managed = false): string | null {
+    if (managed) return null;
+    const session = this.host?.session(id);
+    if (!session) return null;
+    const own = this.forSession(id);
+    if (
+      own &&
+      own.leadId !== id &&
+      (own.status === "active" || own.tasks.some(activeTask))
+    )
+      return "This worker is managed by the orchestrator. Send instructions through its lead or stop the run first.";
+    const other = this.runs.find(
+      (run) =>
+        (run.status === "active" || run.tasks.some(activeTask)) &&
+        run.leadId !== id &&
+        sameCheckout(run.cwd, session.worktreeCwd ?? session.cwd),
+    );
+    if (other)
+      return "This checkout has an active orchestrator. Stop that run before starting independent work.";
+    if (own?.status === "paused")
+      return "Resume or stop orchestration before sending the lead another turn.";
+    if (
+      own?.status === "active" &&
+      !sameCheckout(own.cwd, session.worktreeCwd ?? session.cwd)
+    )
+      return "Return the lead to its original project or stop orchestration first.";
+    return null;
+  }
+  prompt(id: string, prompt: string): string {
+    const run = this.run(id);
+    if (!run || run.status !== "active") return prompt;
+    const cli = `${shellPath(run.cli)} control`;
+    return `${prompt}\n\n<monocode_orchestration>\nYou are the lead of a local MonoCode run. Coordinate the user's task using ${cli}. Run \`${cli} --help\` before your first command; it documents every action, its exact JSON fields and the retry rule. Credentials are already in your environment; never print them.\nEach call prints one JSON line and exits non-zero unless "ok" is true; read the "error" text, it says what to do next. Unknown JSON fields are rejected rather than ignored, so fix the field name instead of guessing. If a call fails before reaching MonoCode, retry it with the "requestId" from that response so the work is never queued twice.\nUse list to discover allowed harness/model IDs. Delegate bounded tasks with project-relative files (directories reserve their descendants), self-contained prompts and dependsOn task IDs. Use the same checkout. You may read and plan; leave file edits to workers. Never start workers outside this CLI. Workers with overlapping files are queued. For installs, Git mutations, generators or broad formatting, assign a separate task with files ["."] and wait for other workers to finish.\nAgents never prompt the user. When one needs an approval or answers a question, list, get and wait report it as needsInput on that task, and you decide with respond or answer; it stays stopped until you do. Judge the request against the task you assigned, and put it to the user in this conversation only when the call is genuinely theirs.\nSteer a running agent with steer to correct its course without losing its work; use message only once it has stopped. Read results with get or wait; completed means a turn finished, not that the work passed review. Review the actual changes, message a worker for fixes, and use review to accept each completed task. Cancel discarded tasks. A failed task blocks finish until you retry it with message or drop it with cancel. Call finish only when required work and combined validation are complete. You receive worker results automatically when idle; use bounded wait calls while supervising. Do not expose credentials, use worktrees, switch branches or silently escalate worker permissions.\n</monocode_orchestration>`;
+  }
+  async handle(
+    leadId: string,
+    requestId: string,
+    action: string,
+    input: Record<string, unknown>,
+  ): Promise<unknown> {
+    checkFields(action, input);
+    const signature = JSON.stringify({ action, input });
+    const key = `${leadId}:${requestId}`;
+    const receipts = this.persisted.get(leadId)?.requests;
+    const previous =
+      receipts &&
+      Object.prototype.hasOwnProperty.call(receipts, requestId) &&
+      typeof receipts[requestId]?.signature === "string"
+        ? receipts[requestId]
+        : undefined;
+    if (previous) {
+      if (previous.signature !== signature)
+        throw new Error("Request ID was already used with different input");
+      return previous.result;
+    }
+    const pending = this.inflight.get(key);
+    if (pending) {
+      if (pending.signature !== signature)
+        throw new Error("Request ID was already used with different input");
+      return pending.promise;
+    }
+    if (action === "wait") return this.wait(leadId, input);
+    const result = this.actions
+      .catch(() => undefined)
+      .then(async () => {
+        const run = this.run(leadId);
+        if (!run || run.status !== "active")
+          throw new Error("This run is not active");
+        if (
+          !["list", "get"].includes(action) &&
+          Object.keys(run.requests).length >= 512
+        )
+          throw new Error(
+            "Run command limit reached. Stop the run and start another after reviewing the files.",
+          );
+        return this.execute(run, action, input, requestId, signature);
+      });
+    this.actions = result.then(
+      () => undefined,
+      () => undefined,
+    );
+    this.inflight.set(key, { signature, promise: result });
+    try {
+      return await result;
+    } finally {
+      this.inflight.delete(key);
+      void this.pump();
+    }
+  }
+  private view(run: OrchestrationRun) {
+    return {
+      ...run,
+      cli: undefined,
+      requests: undefined,
+      tasks: run.tasks.map((task) => ({
+        ...task,
+        prompt: undefined,
+        scopes: undefined,
+        waitingFor: this.waitingFor(run, task),
+        needsInput: this.pendingInput(task),
+      })),
+    };
+  }
+  /**
+   * What a worker is blocked on. Workers have no user-facing prompt: the lead
+   * answers for them, and escalates to the user in its own conversation when
+   * it does not want to decide alone.
+   */
+  pendingInput(task: OrchestrationTask) {
+    const worker = this.host?.session(task.sessionId);
+    const pending = worker && pendingApprovalForSession(worker);
+    if (!pending) return undefined;
+    return {
+      kind: pending.kind,
+      requestId: pending.requestId,
+      label: pending.label,
+      detail:
+        pending.kind === "approval"
+          ? (pending.block?.tool?.detail?.trim() ?? pending.block?.text)
+          : undefined,
+      questions: worker?.pendingQuestion?.questions,
+    };
+  }
+  waitingFor(
+    run: OrchestrationRun,
+    task: OrchestrationTask,
+  ): string | undefined {
+    if (task.status !== "queued") return undefined;
+    const dependency = run.tasks.find(
+      (entry) => task.dependsOn.includes(entry.id) && !entry.accepted,
+    );
+    if (dependency) return `Waiting for review: ${dependency.title}`;
+    const owner = run.tasks.find(
+      (entry) => activeTask(entry) && scopesOverlap(entry.scopes, task.scopes),
+    );
+    if (owner) return `Waiting for files: ${owner.title}`;
+    return "Waiting for a worker slot";
+  }
+  private async execute(
+    run: OrchestrationRun,
+    action: string,
+    input: Record<string, unknown>,
+    requestId: string,
+    signature: string,
+  ): Promise<unknown> {
+    // Persist the mutation and its retry receipt together, before dispatch.
+    const record = async (next: OrchestrationRun, result: unknown) => {
+      await this.commit({
+        ...next,
+        requests: { ...next.requests, [requestId]: { signature, result } },
+      });
+      return result;
+    };
+    const changeTask = (
+      id: string,
+      patch: Partial<OrchestrationTask>,
+      result: unknown,
+    ) => {
+      const current = this.run(run.leadId)!;
+      return record(
+        {
+          ...current,
+          tasks: current.tasks.map((entry) =>
+            entry.id === id ? { ...entry, ...patch } : entry,
+          ),
+        },
+        result,
+      );
+    };
+    const task = () => {
+      const id = text(input.taskId, "taskId", 128);
+      const found = this.run(run.leadId)!.tasks.find(
+        (entry) => entry.id === id,
+      );
+      if (!found)
+        throw new Error(
+          "Task does not belong to this run. Use a taskId returned by delegate or list.",
+        );
+      return found;
+    };
+    switch (action) {
+      case "list":
+        return {
+          run: this.view(run),
+          harnesses: this.host!.choices()
+            .filter((choice) => run.allowedHarnesses.includes(choice.harness))
+            .map((choice) => ({
+              ...choice,
+              models: choice.models.filter(
+                (model) =>
+                  !run.allowedModels ||
+                  run.allowedModels.some(
+                    (allowed) =>
+                      allowed.harness === choice.harness &&
+                      allowed.model === model.id,
+                  ),
+              ),
+            })),
+        };
+      case "get": {
+        // The fields list reports, plus this task's own prompt.
+        const target = task();
+        return {
+          ...target,
+          scopes: undefined,
+          waitingFor: this.waitingFor(this.run(run.leadId)!, target),
+          needsInput: this.pendingInput(target),
+        };
+      }
+      case "delegate": {
+        if (run.tasks.length >= 40)
+          throw new Error("This run has reached its 40-task limit");
+        const harness = text(input.harness, "harness") as HarnessId;
+        if (
+          !HARNESSES.includes(harness) ||
+          !run.allowedHarnesses.includes(harness)
+        )
+          throw new Error(
+            `Harness "${harness}" is not allowed in this run. Allowed: ${listed(run.allowedHarnesses)}.`,
+          );
+        const choice = this.host!.choices().find(
+          (entry) => entry.harness === harness,
+        );
+        if (!choice) throw new Error("Worker harness is unavailable");
+        const permittedModels = choice.models.filter(
+          (model) =>
+            !run.allowedModels ||
+            run.allowedModels.some(
+              (allowed) =>
+                allowed.harness === harness && allowed.model === model.id,
+            ),
+        );
+        const model =
+          input.model == null
+            ? permittedModels[0]?.id
+            : text(input.model, "model", 256);
+        if (!model || !permittedModels.some((item) => item.id === model))
+          throw new Error(
+            `Choose a model ID returned by list for ${harness}: ${listed(permittedModels.map((item) => item.id)) || "none available"}.`,
+          );
+        const title = text(input.title, "title", 160);
+        const prompt = text(input.prompt, "prompt");
+        const files = strings(input.files, "files");
+        if (!files.length)
+          throw new Error(
+            "Declare at least one file/directory scope in files, or '.' for exclusive checkout access",
+          );
+        const dependsOn = strings(input.dependsOn ?? [], "dependsOn", 40);
+        const missing = dependsOn.filter(
+          (id) =>
+            !run.tasks.some(
+              (item) => item.id === id && item.status !== "cancelled",
+            ),
+        );
+        if (missing.length)
+          throw new Error(
+            `dependsOn must hold taskIds from this run; unknown or cancelled: ${listed(missing)}.`,
+          );
+        const scopes = await this.store.scopes(run.cwd, files);
+        const created: OrchestrationTask = {
+          id: crypto.randomUUID(),
+          sessionId: crypto.randomUUID(),
+          title,
+          prompt,
+          files,
+          scopes,
+          dependsOn,
+          harness,
+          model,
+          status: "queued",
+          accepted: false,
+          result: "",
+          delivered: true,
+        };
+        return record(
+          {
+            ...this.run(run.leadId)!,
+            tasks: [...this.run(run.leadId)!.tasks, created],
+          },
+          {
+            taskId: created.id,
+            sessionId: created.sessionId,
+            status: "queued",
+          },
+        );
+      }
+      case "message": {
+        const target = task();
+        if (activeTask(target) || target.status === "queued")
+          throw new Error(
+            `Wait for this worker or cancel it before sending a new turn; ${target.title} is ${target.status}.`,
+          );
+        if (
+          run.tasks.some(
+            (entry) =>
+              entry.dependsOn.includes(target.id) &&
+              entry.status !== "queued" &&
+              entry.status !== "cancelled",
+          )
+        )
+          throw new Error(
+            "A dependent task has already started; create a separate correction task after it finishes",
+          );
+        return changeTask(
+          target.id,
+          {
+            prompt: text(input.text, "text"),
+            status: "queued",
+            accepted: false,
+            result: "",
+            error: undefined,
+            delivered: true,
+          },
+          { taskId: target.id, status: "queued" },
+        );
+      }
+      case "steer": {
+        const target = task();
+        if (target.status !== "running")
+          throw new Error(
+            `Only a running agent can be steered; ${target.title} is ${target.status}. ${
+              target.status === "queued"
+                ? "It has not started yet, so edit it with message instead."
+                : "Send it a fresh turn with message."
+            }`,
+          );
+        const guidance = text(input.text, "text");
+        await this.host!.steer(target.sessionId, guidance);
+        return record(this.run(run.leadId)!, {
+          taskId: target.id,
+          steered: true,
+        });
+      }
+      case "cancel":
+        await this.cancelTask(run.leadId, task().id);
+        return record(this.run(run.leadId)!, { cancelled: true });
+      case "respond": {
+        const target = task();
+        const pending = this.pendingInput(target);
+        if (pending?.kind !== "approval")
+          throw new Error(
+            `${target.title} is not waiting on an approval. Read needsInput from list or wait before responding.`,
+          );
+        if (input.requestId !== pending.requestId)
+          throw new Error(
+            `Stale requestId. ${target.title} is waiting on ${pending.requestId}.`,
+          );
+        const decision = text(input.decision, "decision", 16);
+        if (decision !== "allow" && decision !== "deny")
+          throw new Error('decision must be "allow" or "deny"');
+        this.host!.respondApproval(target.sessionId, pending.requestId, decision);
+        return record(this.run(run.leadId)!, {
+          taskId: target.id,
+          decision,
+        });
+      }
+      case "answer": {
+        const target = task();
+        const pending = this.pendingInput(target);
+        if (pending?.kind !== "question")
+          throw new Error(
+            `${target.title} is not waiting on a question. Read needsInput from list or wait before answering.`,
+          );
+        if (input.requestId !== pending.requestId)
+          throw new Error(
+            `Stale requestId. ${target.title} is waiting on ${pending.requestId}.`,
+          );
+        const reply: UserQuestionReply =
+          input.skip === true
+            ? { kind: "skipped" }
+            : {
+                kind: "answered",
+                answers: questionAnswers(input.answers, pending.questions),
+              };
+        this.host!.answerQuestion(target.sessionId, pending.requestId, reply);
+        return record(this.run(run.leadId)!, {
+          taskId: target.id,
+          answered: reply.kind === "answered",
+        });
+      }
+      case "review": {
+        const target = task();
+        if (target.status !== "completed")
+          throw new Error(
+            `Only a completed result can be accepted; ${target.title} is ${target.status}. ${
+              target.status === "failed"
+                ? "Send it another turn with message, or drop it with cancel."
+                : "Wait for it to finish, or cancel it."
+            }`,
+          );
+        return changeTask(target.id, { accepted: true }, { accepted: true });
+      }
+      case "finish": {
+        const outstanding = this.run(run.leadId)!.tasks.filter(
+          (entry) => entry.status !== "cancelled" && !entry.accepted,
+        );
+        if (outstanding.length)
+          throw new Error(
+            `Review all remaining tasks before finishing. Outstanding: ${listed(
+              outstanding.map((entry) => `${entry.title} (${entry.status})`),
+            )}. Accept a completed task with review, send a failed one another turn with message, or drop it with cancel.`,
+          );
+        const result = await record(
+          { ...this.run(run.leadId)!, status: "finished" },
+          { finished: true },
+        );
+        await this.store.disable(run.leadId);
+        return result;
+      }
+      default:
+        throw new Error("Unknown action. Run control --help.");
+    }
+  }
+  private async wait(leadId: string, input: Record<string, unknown>) {
+    const run = this.run(leadId);
+    if (!run || run.status !== "active")
+      throw new Error("This run is not active");
+    const seconds = input.timeoutSeconds ?? 20;
+    if (
+      typeof seconds !== "number" ||
+      !Number.isFinite(seconds) ||
+      seconds < 0 ||
+      seconds > 25
+    )
+      throw new Error("timeoutSeconds must be 0 to 25");
+    // A worker blocking on the lead changes no run state, so watch for that
+    // separately; otherwise the lead sleeps while an agent waits on it.
+    const blocked = this.blocked.get(leadId);
+    if (
+      run.tasks.some(activeTask) ||
+      run.tasks.some((task) => task.status === "queued")
+    ) {
+      await new Promise<void>((resolve) => {
+        const finish = () => {
+          clearTimeout(timer);
+          unsubscribe();
+          resolve();
+        };
+        const unsubscribe = this.subscribe(() => {
+          if (this.run(leadId) !== run || this.blocked.get(leadId) !== blocked)
+            finish();
+        });
+        const timer = setTimeout(finish, seconds * 1000);
+      });
+    }
+    return this.view(this.run(leadId)!);
+  }
+  private async pump() {
+    if (this.pumping) {
+      this.pumpAgain = true;
+      return;
+    }
+    if (!this.host) return;
+    this.pumping = true;
+    try {
+      for (const initial of this.runs) {
+        const initialRun = this.run(initial.leadId);
+        if (!initialRun || initialRun.status !== "active") continue;
+        for (const initialTask of initialRun.tasks) {
+          const run = this.run(initial.leadId);
+          if (
+            !run ||
+            run.status !== "active" ||
+            run.tasks.filter(activeTask).length >= run.maxWorkers
+          )
+            break;
+          const task = run.tasks.find((entry) => entry.id === initialTask.id);
+          if (
+            !task ||
+            task.status !== "queued" ||
+            task.dependsOn.some(
+              (id) => !run.tasks.find((entry) => entry.id === id)?.accepted,
+            )
+          )
+            continue;
+          if (
+            run.tasks.some(
+              (entry) =>
+                activeTask(entry) && scopesOverlap(entry.scopes, task.scopes),
+            )
+          )
+            continue;
+          if (!this.host.session(run.leadId)) {
+            await this.stopRun(run.leadId);
+            break;
+          }
+          await this.patchTask(run.leadId, task.id, { status: "running" });
+          try {
+            if (
+              !this.host
+                .choices()
+                .some(
+                  (choice) =>
+                    choice.harness === task.harness &&
+                    choice.models.some((model) => model.id === task.model),
+                )
+            )
+              throw new Error(
+                "The assigned harness/model is no longer available. Review this task before retrying.",
+              );
+            await this.host.createWorker(run, task);
+            if (
+              this.run(run.leadId)?.status !== "active" ||
+              this.run(run.leadId)?.tasks.find((entry) => entry.id === task.id)
+                ?.status !== "running"
+            )
+              continue;
+            const prompt = workerTurnPrompt(task.prompt, task.files);
+            this.host.submit(task.sessionId, prompt, (outcome) => {
+              void this.settle(run.leadId, task.id, outcome).catch(
+                console.error,
+              );
+            });
+          } catch (error) {
+            await this.settle(run.leadId, task.id, {
+              status: "failed",
+              text: "",
+              error: messageOf(error),
+            });
+          }
+        }
+      }
+    } catch (error) {
+      console.error("Orchestration dispatch failed", error);
+    } finally {
+      this.pumping = false;
+      if (this.pumpAgain) {
+        this.pumpAgain = false;
+        void this.pump();
+      }
+    }
+  }
+  private async settle(
+    leadId: string,
+    taskId: string,
+    outcome: ControlOutcome,
+  ) {
+    const task = this.run(leadId)?.tasks.find((entry) => entry.id === taskId);
+    if (!task || task.status !== "running") return;
+    await this.patchTask(leadId, taskId, {
+      status: outcome.status,
+      result: outcome.text.slice(-20_000),
+      error: outcome.error,
+      delivered: false,
+      accepted: false,
+    });
+    void this.pump();
+    this.sync();
+  }
+  async cancelTask(leadId: string, taskId: string) {
+    const task = this.run(leadId)?.tasks.find((entry) => entry.id === taskId);
+    if (!task || task.status === "cancelled") return;
+    if (activeTask(task)) {
+      await this.patchTask(leadId, taskId, { status: "cancelling" });
+      await this.host!.stop(task.sessionId);
+    }
+    await this.patchTask(leadId, taskId, {
+      status: "cancelled",
+      accepted: false,
+      delivered: false,
+    });
+    void this.pump();
+  }
+  /**
+   * A paused run has no supervisor, so its agents stop with it. Leaving them
+   * editing the shared checkout with nobody reviewing is how a run quietly
+   * diverges from what the user approved. Queued work is left alone: `pump`
+   * will not dispatch while paused, so it resumes intact.
+   */
+  private async pause(
+    leadId: string,
+    error: string,
+    patch?: (run: OrchestrationRun) => OrchestrationRun,
+  ) {
+    const run = this.run(leadId);
+    if (!run || run.status !== "active") return;
+    await this.commit({ ...(patch ? patch(run) : run), status: "paused", error });
+    await Promise.all(
+      this.run(leadId)!
+        .tasks.filter(activeTask)
+        .map((task) => this.cancelTask(leadId, task.id)),
+    );
+  }
+  async stopRun(leadId: string) {
+    const run = this.run(leadId);
+    if (!run) return;
+    let saveError: unknown;
+    await this.commit({ ...run, status: "stopped" }).catch((error: unknown) => {
+      saveError = error;
+    });
+    await Promise.all(
+      [
+        leadId,
+        ...run.tasks.filter(activeTask).map((task) => task.sessionId),
+      ].map((id) => this.host?.stop(id)),
+    );
+    const latest = this.run(leadId)!;
+    const stopped: OrchestrationRun = {
+      ...latest,
+      status: "stopped",
+      tasks: latest.tasks.map((task) =>
+        activeTask(task) || task.status === "queued"
+          ? { ...task, status: "cancelled", accepted: false, delivered: true }
+          : task,
+      ),
+    };
+    await this.commit(stopped).catch((error: unknown) => {
+      saveError = error;
+    });
+    this.runs = this.runs.map((entry) =>
+      entry.leadId === leadId
+        ? {
+            ...stopped,
+            error: saveError
+              ? `Run stopped; could not save history: ${messageOf(saveError)}`
+              : undefined,
+          }
+        : entry,
+    );
+    this.emit();
+    await this.store.disable(leadId);
+  }
+  stopForSession(id: string): Promise<void> | null {
+    const run = this.forSession(id);
+    if (
+      !run ||
+      (run.status !== "active" &&
+        run.status !== "paused" &&
+        !run.tasks.some(activeTask))
+    )
+      return null;
+    if (run.leadId === id) return this.stopRun(id);
+    const task = run.tasks.find((entry) => entry.sessionId === id)!;
+    return this.cancelTask(run.leadId, task.id);
+  }
+  /** Drain control writes before the database removes a lead or one of its workers. */
+  deleteSession(id: string, remove: () => Promise<void>): Promise<void> {
+    const result = this.actions.catch(() => undefined).then(async () => {
+      const run = this.forSession(id);
+      if (
+        run &&
+        (run.status === "active" ||
+          run.status === "paused" ||
+          run.tasks.some(activeTask))
+      ) {
+        await this.stopRun(run.leadId);
+      }
+      await this.saves.catch(() => undefined);
+      await remove();
+      this.deleted.add(id);
+      if (!run) return;
+      this.runs = this.runs.filter((entry) => entry.leadId !== run.leadId);
+      this.persisted.delete(run.leadId);
+      this.blocked.delete(run.leadId);
+      this.announced.delete(run.leadId);
+      this.emit();
+      if (run.leadId !== id) {
+        // Read the transaction's pruned graph; never save the pre-delete snapshot.
+        const updated = await this.store.load(run.leadId).catch((error) => {
+          console.error("Could not reload orchestration after deletion", error);
+          this.loaded.delete(run.leadId);
+          return null;
+        });
+        if (updated) {
+          this.runs = [...this.runs, updated];
+          this.persisted.set(run.leadId, updated);
+          this.emit();
+        }
+      }
+    });
+    this.actions = result.catch(() => undefined);
+    return result;
+  }
+  /** `${taskId}:${requestId}` for every worker currently blocked on the lead. */
+  private blockedKeys(run: OrchestrationRun): string[] {
+    return run.tasks.flatMap((task) => {
+      const pending = this.pendingInput(task);
+      return pending ? [`${task.id}:${pending.requestId}`] : [];
+    });
+  }
+  sync() {
+    for (const run of this.runs) {
+      if (run.status !== "active") continue;
+      // A blocked worker changes no run state, so `wait` needs telling.
+      const keys = this.blockedKeys(run).join(",");
+      if (this.blocked.get(run.leadId) !== keys) {
+        this.blocked.set(run.leadId, keys);
+        this.emit();
+      }
+    }
+    for (const run of this.runs) {
+      if (run.status !== "active" || this.waking.has(run.leadId)) continue;
+      const lead = this.host?.session(run.leadId);
+      if (!lead || lead.busy || lead.queuedMessages?.length) continue;
+      const announced = this.announced.get(run.leadId) ?? new Set<string>();
+      const results = run.tasks.filter((task) => !task.delivered);
+      const blocked = this.blockedKeys(run).filter(
+        (key) => !announced.has(key),
+      );
+      if (!results.length && !blocked.length) continue;
+      this.waking.add(run.leadId);
+      // Let session state settle before checking idle; never interrupt user input.
+      setTimeout(() => {
+        void (async () => {
+          try {
+            const current = this.run(run.leadId);
+            const session = this.host?.session(run.leadId);
+            if (
+              !current ||
+              current.status !== "active" ||
+              !session ||
+              session.busy ||
+              session.queuedMessages?.length
+            )
+              return;
+            const results = current.tasks.filter(
+              (task) =>
+                !task.delivered &&
+                !activeTask(task) &&
+                task.status !== "queued",
+            );
+            const seen = this.announced.get(run.leadId) ?? new Set<string>();
+            const waiting = current.tasks.flatMap((task) => {
+              const pending = this.pendingInput(task);
+              const key = pending && `${task.id}:${pending.requestId}`;
+              return key && !seen.has(key) ? [{ task, pending, key }] : [];
+            });
+            if (!results.length && !waiting.length) return;
+            if (current.continuations >= 20) {
+              await this.pause(
+                run.leadId,
+                "Automatic continuation limit reached. Its agents were stopped; review and resume the run.",
+              );
+              return;
+            }
+            await this.commit({
+              ...current,
+              continuations: current.continuations + 1,
+              tasks: current.tasks.map((task) =>
+                results.some((item) => item.id === task.id)
+                  ? { ...task, delivered: true }
+                  : task,
+              ),
+            });
+            this.announced.set(
+              run.leadId,
+              new Set([...seen, ...waiting.map((entry) => entry.key)]),
+            );
+            const summary = results
+              .map(
+                (task) =>
+                  `${task.id} — ${task.title}: ${task.status}\n${task.error ?? ""}\n${task.result.slice(-4000)}`,
+              )
+              .join("\n\n");
+            const asks = waiting
+              .map(
+                ({ task, pending }) =>
+                  `${task.id} — ${task.title} needs ${pending.kind === "approval" ? "an approval" : "an answer"} (requestId ${pending.requestId}): ${pending.label}\n${pending.detail?.slice(0, 2000) ?? ""}${
+                    pending.questions
+                      ? `\n${JSON.stringify(pending.questions)}`
+                      : ""
+                  }`,
+              )
+              .join("\n\n");
+            const body = [
+              results.length
+                ? `Worker results are ready. Review the work, request corrections through the CLI when needed, and finish the original task.\n\n${summary}`
+                : "",
+              waiting.length
+                ? `These agents are blocked waiting on you. Decide each one with respond or answer; they stay stopped until you do. Judge it against the task you assigned, and ask the user in this conversation only when the call is genuinely theirs to make.\n\n${asks}`
+                : "",
+            ]
+              .filter(Boolean)
+              .join("\n\n");
+            this.host!.submit(
+              run.leadId,
+              body,
+              (outcome) => {
+                if (outcome.status !== "completed") {
+                  void this.pause(
+                    run.leadId,
+                    outcome.error ??
+                      "Lead continuation was interrupted. Its agents were stopped; review and resume.",
+                    (current) => ({
+                      ...current,
+                      tasks: current.tasks.map((task) =>
+                        results.some((item) => item.id === task.id)
+                          ? { ...task, delivered: false }
+                          : task,
+                      ),
+                    }),
+                  ).catch(console.error);
+                } else this.sync();
+              },
+            );
+          } catch (error) {
+            console.error("Orchestration continuation failed", error);
+          } finally {
+            this.waking.delete(run.leadId);
+          }
+        })();
+      }, 0);
+    }
+  }
+  observe(id: string, event: HarnessEvent) {
+    if (event.type !== "tool.started" && event.type !== "tool.updated") return;
+    const run = this.forSession(id);
+    const task = run?.tasks.find(
+      (entry) => entry.sessionId === id && entry.status === "running",
+    );
+    if (
+      !run ||
+      run.status !== "active" ||
+      !task ||
+      event.preview?.kind !== "write"
+    )
+      return;
+    const paths =
+      event.paths ?? (event.preview.path ? [event.preview.path] : []);
+    for (const path of paths) {
+      const absolute = /^(\/|[a-z]:[\\/])/i.test(path)
+        ? path
+        : `${run.canonicalRoot ?? run.cwd}/${path}`;
+      const parts: string[] = [];
+      for (const part of absolute
+        .replace(/\\/g, "/")
+        .toLowerCase()
+        .split("/")) {
+        if (part === "..") parts.pop();
+        else if (part !== ".") parts.push(part);
+      }
+      const normalized = parts.join("/");
+      if (
+        task.scopes.some(
+          (scope) => normalized === scope || normalized.startsWith(`${scope}/`),
+        )
+      )
+        continue;
+      void (async () => {
+        await this.commit({
+          ...this.run(run.leadId)!,
+          status: "paused",
+          error: `${task.title} reported a write outside its assignment: ${path}. Review the shared files before resuming.`,
+        });
+        await Promise.all(
+          this.run(run.leadId)!
+            .tasks.filter(activeTask)
+            .map((entry) => this.cancelTask(run.leadId, entry.id)),
+        );
+      })().catch(console.error);
+      break;
+    }
+  }
+}
+
+export const orchestrator = new Orchestrator();
diff --git a/src/lib/orchestrationCatalog.test.ts b/src/lib/orchestrationCatalog.test.ts
new file mode 100644
index 00000000..06cde591
--- /dev/null
+++ b/src/lib/orchestrationCatalog.test.ts
@@ -0,0 +1,68 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+vi.mock("./harness/availability", () => ({
+  isHarnessAvailable: vi.fn((id: string) => id === "codex" || id === "claude"),
+  probeHarnessAvailability: vi.fn(async () => {}),
+}));
+vi.mock("./harness/registry", () => ({
+  refreshHarnessCatalogs: vi.fn(async () => {}),
+}));
+import { discoverOrchestrationSettings } from "./orchestrationCatalog";
+import {
+  isHarnessAvailable,
+  probeHarnessAvailability,
+} from "./harness/availability";
+import { refreshHarnessCatalogs } from "./harness/registry";
+import { resetHarnessModelOverlays, setHarnessModels } from "./models";
+
+afterEach(() => {
+  resetHarnessModelOverlays();
+  vi.clearAllMocks();
+  vi.mocked(isHarnessAvailable).mockImplementation(
+    (id) => id === "codex" || id === "claude",
+  );
+});
+
+describe("automatic orchestration catalog", () => {
+  it("discovers every installed harness and reads its refreshed models without a user-selected pool", async () => {
+    vi.mocked(refreshHarnessCatalogs).mockImplementationOnce(async () => {
+      setHarnessModels("codex", [
+        { id: "codex:live", harness: "codex", name: "Live Codex" },
+      ]);
+    });
+    const settings = await discoverOrchestrationSettings();
+    expect(probeHarnessAvailability).toHaveBeenCalledOnce();
+    expect(refreshHarnessCatalogs).toHaveBeenCalledWith(["claude", "codex"]);
+    expect(settings.choices).toContainEqual({
+      harness: "codex",
+      model: "codex:live",
+      name: "Live Codex",
+    });
+    expect(settings.choices.some((choice) => choice.harness === "claude")).toBe(
+      true,
+    );
+    expect(settings.choices.some((choice) => choice.harness === "cursor")).toBe(
+      false,
+    );
+    expect(settings.maxWorkers).toBe(2);
+  });
+  it("does not truncate catalogs at the former manual-selection limit", async () => {
+    setHarnessModels(
+      "codex",
+      Array.from({ length: 80 }, (_, i) => ({
+        id: `codex:${i}`,
+        harness: "codex",
+        name: `Model ${i}`,
+      })),
+    );
+    const settings = await discoverOrchestrationSettings();
+    expect(
+      settings.choices.filter((choice) => choice.harness === "codex"),
+    ).toHaveLength(80);
+  });
+  it("fails planning clearly when no harness is available", async () => {
+    vi.mocked(isHarnessAvailable).mockReturnValue(false);
+    await expect(discoverOrchestrationSettings()).rejects.toThrow(
+      "No worker models are available",
+    );
+  });
+});
diff --git a/src/lib/orchestrationCatalog.ts b/src/lib/orchestrationCatalog.ts
new file mode 100644
index 00000000..c9a92969
--- /dev/null
+++ b/src/lib/orchestrationCatalog.ts
@@ -0,0 +1,27 @@
+import { HARNESSES } from "./session";
+import { modelsFor } from "./models";
+import {
+  isHarnessAvailable,
+  probeHarnessAvailability,
+} from "./harness/availability";
+import { refreshHarnessCatalogs } from "./harness/registry";
+import { validateOrchestrationSettings } from "./orchestrationPlan";
+
+/** Discover worker choices only when the user sends an orchestration request. */
+export async function discoverOrchestrationSettings() {
+  await probeHarnessAvailability();
+  const installed = HARNESSES.filter(isHarnessAvailable);
+  await refreshHarnessCatalogs(installed);
+  return validateOrchestrationSettings({
+    maxWorkers: 2,
+    choices: installed
+      .filter(isHarnessAvailable)
+      .flatMap((harness) =>
+        modelsFor(harness).map(({ id, name }) => ({
+          harness,
+          model: id,
+          name,
+        })),
+      ),
+  });
+}
diff --git a/src/lib/orchestrationPlan.test.ts b/src/lib/orchestrationPlan.test.ts
new file mode 100644
index 00000000..4b3af7f7
--- /dev/null
+++ b/src/lib/orchestrationPlan.test.ts
@@ -0,0 +1,137 @@
+import { describe, expect, it } from "vitest";
+import {
+  completeOrchestrationProposal,
+  orchestrationPlanningPrompt,
+  proposalBlock,
+  validateProposedTasks,
+  type OrchestrationProposal,
+} from "./orchestrationPlan";
+import { newSession } from "./session";
+import { sanitizeSessionForPersist } from "./sessionStore";
+import { stopStreaming } from "./harness/apply";
+
+const draft: OrchestrationProposal = {
+  version: 1,
+  leadId: "lead",
+  cwd: "/repo",
+  request: "Build settings",
+  author: { harness: "claude", model: "claude:test", name: "Lead" },
+  settings: {
+    choices: [{ harness: "codex", model: "codex:test", name: "Worker" }],
+    maxWorkers: 2,
+  },
+  status: "planning",
+  title: "Planning",
+  summary: "",
+  tasks: [],
+};
+const task = {
+  id: "ui",
+  title: "Settings UI",
+  prompt: "Build the view",
+  harness: "codex",
+  model: "codex:test",
+  files: ["src/settings"],
+  dependsOn: [],
+};
+const payload = {
+  title: "Settings",
+  summary: "Build the view, then validate",
+  tasks: [task],
+};
+
+describe("orchestration proposals", () => {
+  it("prompts the current lead with the available model catalog and no execution authority", () => {
+    const prompt = orchestrationPlanningPrompt(draft.request, draft.settings);
+    expect(prompt).toContain("do not edit files, start workers");
+    expect(prompt).toContain('"model":"codex:test"');
+    expect(prompt).toContain("until the user confirms");
+    expect(prompt).toContain("<monocode_proposal>");
+    expect(prompt).toContain("fewest useful tasks");
+    expect(prompt).toContain("Do not ask the user to assemble a team");
+    expect(prompt).toContain("disjoint files");
+    expect(prompt).toContain("acceptance checks");
+  });
+  it("turns the lead's structured response into a ready card without changing the discovered catalog", () => {
+    const result = completeOrchestrationProposal(
+      draft,
+      `Commentary\n<monocode_proposal>${JSON.stringify({ ...payload, settings: { choices: [] } })}</monocode_proposal>`,
+    );
+    expect(result.status).toBe("ready");
+    expect(result.tasks).toEqual(payload.tasks);
+    expect(result.settings).toEqual(draft.settings);
+    expect(result.author).toEqual(draft.author);
+  });
+  it("accepts fenced JSON and rejects prose or a model outside the available catalog", () => {
+    expect(
+      completeOrchestrationProposal(
+        draft,
+        "```json\n" + JSON.stringify(payload) + "\n```",
+      ).status,
+    ).toBe("ready");
+    expect(
+      completeOrchestrationProposal(draft, "I will implement it now").status,
+    ).toBe("invalid");
+    const invalid = completeOrchestrationProposal(
+      draft,
+      JSON.stringify({
+        ...payload,
+        tasks: [{ ...task, model: "codex:unselected" }],
+      }),
+    );
+    expect(invalid.status).toBe("invalid");
+    expect(invalid.error).toContain("available catalog");
+    expect(invalid.tasks).toEqual([]);
+  });
+  it("validates cycles, unknown dependencies and path escapes before execution", () => {
+    const settings = draft.settings;
+    expect(() =>
+      validateProposedTasks([{ ...task, dependsOn: ["ui"] }], settings),
+    ).toThrow("cycle");
+    expect(() =>
+      validateProposedTasks([{ ...task, dependsOn: ["missing"] }], settings),
+    ).toThrow("unknown assignment");
+    expect(() =>
+      validateProposedTasks([{ ...task, files: ["../outside"] }], settings),
+    ).toThrow("project-relative");
+    expect(() => validateProposedTasks([task, task], settings)).toThrow(
+      "unique",
+    );
+    expect(
+      validateProposedTasks(
+        [
+          { ...task, dependsOn: ["data"] },
+          { ...task, id: "data" },
+        ],
+        settings,
+      ),
+    ).toHaveLength(2);
+  });
+  it("keeps model edits and assignments through persistence", () => {
+    const proposal = completeOrchestrationProposal(
+      draft,
+      JSON.stringify(payload),
+    );
+    proposal.tasks[0].prompt = "User edited the instructions";
+    const session = {
+      ...newSession("claude", "/repo"),
+      blocks: [proposalBlock("proposal", proposal)],
+    };
+    expect(sanitizeSessionForPersist(session).blocks[0].orchestration).toEqual(
+      proposal,
+    );
+  });
+  it("makes interrupted planning non-executable on stop and reload", () => {
+    const session = {
+      ...newSession("claude", "/repo"),
+      busy: true,
+      blocks: [proposalBlock("proposal", draft)],
+    };
+    expect(stopStreaming(session).blocks[0].orchestration?.status).toBe(
+      "invalid",
+    );
+    expect(
+      sanitizeSessionForPersist(session).blocks[0].orchestration?.status,
+    ).toBe("invalid");
+  });
+});
diff --git a/src/lib/orchestrationPlan.ts b/src/lib/orchestrationPlan.ts
new file mode 100644
index 00000000..6c4d0704
--- /dev/null
+++ b/src/lib/orchestrationPlan.ts
@@ -0,0 +1,267 @@
+import { HARNESSES, type Block, type HarnessId, type Session } from "./session";
+
+export type OrchestrationChoice = {
+  harness: HarnessId;
+  model: string;
+  name: string;
+};
+export type OrchestrationSettings = {
+  choices: OrchestrationChoice[];
+  maxWorkers: number;
+};
+export type ProposedTask = {
+  id: string;
+  title: string;
+  prompt: string;
+  harness: HarnessId;
+  model: string;
+  files: string[];
+  dependsOn: string[];
+};
+export type OrchestrationProposal = {
+  version: 1;
+  leadId: string;
+  cwd: string;
+  request: string;
+  author: OrchestrationChoice;
+  settings: OrchestrationSettings;
+  status: "planning" | "ready" | "invalid" | "starting" | "approved";
+  title: string;
+  summary: string;
+  tasks: ProposedTask[];
+  error?: string;
+};
+
+function required(value: unknown, label: string, max = 30_000): string {
+  if (typeof value !== "string" || !value.trim() || value.length > max)
+    throw new Error(`Provide ${label}`);
+  return value.trim();
+}
+function record(value: unknown): Record<string, unknown> {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error("Expected an assignment object");
+  return value as Record<string, unknown>;
+}
+function stringList(value: unknown, label: string, max: number): string[] {
+  if (!Array.isArray(value) || value.length > max)
+    throw new Error(`Invalid ${label}`);
+  return [
+    ...new Set(
+      value
+        .filter((item) => item !== "")
+        .map((item) => required(item, label, 512)),
+    ),
+  ];
+}
+
+export function validateOrchestrationSettings(
+  value: unknown,
+): OrchestrationSettings {
+  const input = record(value);
+  if (
+    !Number.isInteger(input.maxWorkers) ||
+    Number(input.maxWorkers) < 1 ||
+    Number(input.maxWorkers) > 4
+  )
+    throw new Error("Choose 1 to 4 parallel workers");
+  if (
+    !Array.isArray(input.choices) ||
+    !input.choices.length ||
+    input.choices.length > 4096
+  )
+    throw new Error(
+      "No worker models are available, or the model catalog is too large. Check your connected harnesses.",
+    );
+  const choices = input.choices.map((value) => {
+    const item = record(value);
+    const harness = required(item.harness, "a harness", 32) as HarnessId;
+    if (!HARNESSES.includes(harness)) throw new Error("Unknown worker harness");
+    return {
+      harness,
+      model: required(item.model, "a model", 256),
+      name: required(item.name, "a model name", 256),
+    };
+  });
+  return {
+    maxWorkers: Number(input.maxWorkers),
+    choices: choices.filter(
+      (choice, index) =>
+        choices.findIndex(
+          (entry) =>
+            entry.harness === choice.harness && entry.model === choice.model,
+        ) === index,
+    ),
+  };
+}
+
+/** Validate the entire graph before enabling any process or acquiring scopes. */
+export function validateProposedTasks(
+  value: unknown,
+  settings: OrchestrationSettings,
+): ProposedTask[] {
+  if (!Array.isArray(value) || !value.length || value.length > 40)
+    throw new Error("Provide 1 to 40 assignments");
+  const tasks = value.map((value) => {
+    const task = record(value);
+    const harness = required(task.harness, "a harness", 32) as HarnessId;
+    const model = required(task.model, "a model", 256);
+    if (
+      !settings.choices.some(
+        (choice) => choice.harness === harness && choice.model === model,
+      )
+    )
+      throw new Error(
+        "An assignment uses a model outside the available catalog",
+      );
+    const id = required(task.id, "an assignment ID", 64);
+    if (!/^[A-Za-z0-9_-]+$/.test(id))
+      throw new Error(
+        "Assignment IDs must contain letters, numbers, underscores or hyphens",
+      );
+    const files = stringList(task.files, "file scopes", 64);
+    if (
+      !files.length ||
+      files.some(
+        (path) =>
+          /^(\/|\\|[a-z]:)/i.test(path) || path.split(/[\\/]/).includes(".."),
+      )
+    )
+      throw new Error(
+        "Use project-relative file scopes, or '.' for the whole project",
+      );
+    return {
+      id,
+      title: required(task.title, "a task title", 160),
+      prompt: required(task.prompt, "task instructions"),
+      harness,
+      model,
+      files,
+      dependsOn: stringList(task.dependsOn ?? [], "dependencies", 40),
+    };
+  });
+  const ids = new Set(tasks.map((task) => task.id));
+  if (ids.size !== tasks.length)
+    throw new Error("Assignment IDs must be unique");
+  const visited = new Set<string>();
+  const visiting = new Set<string>();
+  const visit = (id: string) => {
+    if (!ids.has(id))
+      throw new Error("A dependency references an unknown assignment");
+    if (visiting.has(id))
+      throw new Error("Assignments have a dependency cycle");
+    if (visited.has(id)) return;
+    visiting.add(id);
+    tasks.find((task) => task.id === id)!.dependsOn.forEach(visit);
+    visiting.delete(id);
+    visited.add(id);
+  };
+  tasks.forEach((task) => visit(task.id));
+  return tasks;
+}
+
+export function orchestrationPlanningPrompt(
+  request: string,
+  settings: OrchestrationSettings,
+): string {
+  return [
+    "Prepare an orchestration proposal for the user to review in MonoCode. Investigate and plan only: do not edit files, start workers, or invoke the MonoCode control CLI. No execution is authorized until the user confirms the assignment card.",
+    "You are the orchestrator: the user selected you in the composer model picker. Decide the task breakdown and choose each worker's harness and model from the available catalog below. Do not ask the user to assemble a team. They can change your choices in the card before confirming.",
+    "Keep planning efficient: inspect only what is needed to understand the request and relevant project conventions. Use the fewest useful tasks, with clear deliverables and acceptance checks. Do not create agents for trivial steps or duplicate investigation. Prefer a fast, economical model for straightforward work and a more capable model when complexity warrants it; do not invent model capabilities or prices. Reuse a suitable harness/model across tasks when that is sufficient. Explain your overall division of work briefly in the summary.",
+    'Use only exact harness/model pairs from the catalog. Give each task self-contained instructions and project-relative write scopes; directories own their descendants. Parallelize independent work with disjoint files. Serialize shared-file edits with dependencies and avoid concurrent repository-wide commands. Assign shared operations and final combined validation to a task with files ["."]. All workers use one shared checkout without worktrees.',
+    "Return your final proposal as one JSON object inside <monocode_proposal>...</monocode_proposal>. The app renders it as an editable card, so do not ask for approval in prose. No Markdown inside the JSON fields. Tasks may reference any task ID; the graph must be acyclic.",
+    'Schema: {"title":"Short project title","summary":"What you will do and how the work fits together","tasks":[{"id":"task-1","title":"Short task title","prompt":"Self-contained instructions, constraints and checks","harness":"exact harness ID","model":"exact model ID","files":["src/feature"],"dependsOn":[]}]}',
+    `Parallel worker limit: ${settings.maxWorkers}`,
+    `<available_models>\n${JSON.stringify(settings.choices)}\n</available_models>`,
+    `<user_request>\n${request}\n</user_request>`,
+  ].join("\n\n");
+}
+
+export function completeOrchestrationProposal(
+  draft: OrchestrationProposal,
+  response: string,
+  error?: string,
+): OrchestrationProposal {
+  try {
+    if (error) throw new Error(error);
+    const tagged = response.match(
+      /<monocode_proposal>\s*([\s\S]*?)\s*<\/monocode_proposal>/,
+    );
+    const fenced = response.match(/```(?:json)?\s*([\s\S]*?)```/);
+    const raw = (tagged?.[1] ?? fenced?.[1] ?? response).trim();
+    const input = record(JSON.parse(raw));
+    return {
+      ...draft,
+      title: required(input.title, "a proposal title", 160),
+      summary: required(input.summary, "a proposal summary", 2000),
+      tasks: validateProposedTasks(input.tasks, draft.settings),
+      status: "ready",
+      error: undefined,
+    };
+  } catch (reason) {
+    return {
+      ...draft,
+      status: "invalid",
+      error:
+        error ??
+        `Could not prepare the assignment card: ${reason instanceof Error ? reason.message : String(reason)}`,
+    };
+  }
+}
+
+export function proposalMarkdown(proposal: OrchestrationProposal): string {
+  return [
+    `# ${proposal.title}`,
+    proposal.summary,
+    ...proposal.tasks.map(
+      (task) =>
+        `## ${task.title}\n${task.harness} · ${proposal.settings.choices.find((choice) => choice.harness === task.harness && choice.model === task.model)?.name ?? task.model}\n${task.prompt}\nFiles: ${task.files.join(", ")}\nDepends on: ${task.dependsOn.join(", ") || "None"}`,
+    ),
+  ].join("\n\n");
+}
+
+export function withOrchestrationProposal(
+  session: Session,
+  blockId: string,
+  proposal: OrchestrationProposal,
+): Session {
+  return {
+    ...session,
+    blocks: session.blocks.map((block) =>
+      block.id === blockId
+        ? {
+            ...block,
+            text: proposalMarkdown(proposal),
+            orchestration: proposal,
+            streaming: proposal.status === "planning",
+          }
+        : block,
+    ),
+  };
+}
+
+export function proposalBlock(
+  id: string,
+  proposal: OrchestrationProposal,
+): Block {
+  return {
+    id,
+    role: "plan",
+    text: proposalMarkdown(proposal),
+    orchestration: proposal,
+    streaming: true,
+  };
+}
+
+/** A reload must never turn a half-generated card into an executable plan. */
+export function restoreOrchestrationProposal(
+  value: OrchestrationProposal,
+): OrchestrationProposal {
+  if (value.status === "planning")
+    return {
+      ...value,
+      status: "invalid",
+      error: "Planning was interrupted. Generate the assignments again.",
+    };
+  if (value.status === "starting") return { ...value, status: "ready" };
+  return value;
+}
diff --git a/src/lib/orchestrationSummary.ts b/src/lib/orchestrationSummary.ts
new file mode 100644
index 00000000..849f5d95
--- /dev/null
+++ b/src/lib/orchestrationSummary.ts
@@ -0,0 +1,57 @@
+import type { OrchestrationRun, TaskStatus } from "./orchestration";
+import { sessionNeedsInput, type HarnessId, type Session } from "./session";
+
+/** Small history projection; never includes prompts, results or credentials. */
+export type OrchestrationSummary = {
+  status: OrchestrationRun["status"];
+  live?: boolean;
+  tasks: {
+    sessionId: string;
+    title: string;
+    harness: HarnessId;
+    model: string;
+    status: TaskStatus;
+    needsInput?: boolean;
+  }[];
+};
+
+export function summarizeOrchestration(
+  run: OrchestrationRun,
+  sessions: readonly Session[],
+): OrchestrationSummary {
+  const byId = new Map(sessions.map((session) => [session.id, session]));
+  return {
+    status: run.status,
+    live: true,
+    tasks: run.tasks.map(({ sessionId, title, harness, model, status }) => ({
+      sessionId,
+      title,
+      harness,
+      model,
+      status,
+      needsInput:
+        !!byId.get(sessionId) && sessionNeedsInput(byId.get(sessionId)!),
+    })),
+  };
+}
+
+export function orchestrationTaskLabel(
+  task: OrchestrationSummary["tasks"][number],
+  summary: OrchestrationSummary,
+): string {
+  if (task.needsInput) return "Needs input";
+  if (
+    !summary.live &&
+    ["running", "cancelling", "queued"].includes(task.status)
+  )
+    return "Saved";
+  if (summary.status === "paused" && task.status === "queued") return "Paused";
+  return {
+    queued: "Queued",
+    running: "Working",
+    cancelling: "Stopping",
+    completed: "Done",
+    failed: "Failed",
+    cancelled: "Cancelled",
+  }[task.status];
+}
diff --git a/src/lib/orchestrationWorkspace.test.ts b/src/lib/orchestrationWorkspace.test.ts
new file mode 100644
index 00000000..0c5840da
--- /dev/null
+++ b/src/lib/orchestrationWorkspace.test.ts
@@ -0,0 +1,139 @@
+import { describe, expect, it, vi } from "vitest";
+import {
+  attachOrchestrationWorkers,
+  consolidateOrchestrationTabs,
+  prepareOrchestrationWorkerDetails,
+  releaseOrchestrationWorker,
+} from "./orchestrationWorkspace";
+import { leafIds, newTab, splitPane } from "./layout";
+import { newSession } from "./session";
+import type { OrchestrationRun, OrchestrationTask } from "./orchestration";
+
+const tasks: OrchestrationTask[] = ["worker-a", "worker-b"].map(
+  (sessionId) => ({
+    id: sessionId,
+    sessionId,
+    title: sessionId,
+    harness: "claude",
+    model: "claude:test",
+    prompt: "Work",
+    files: [sessionId],
+    scopes: [`/repo/${sessionId}`],
+    dependsOn: [],
+    status: "running",
+    accepted: false,
+    result: "",
+    delivered: false,
+  }),
+);
+const run: OrchestrationRun = {
+  version: 1,
+  leadId: "lead",
+  cwd: "/repo",
+  status: "active",
+  allowedHarnesses: ["claude"],
+  maxWorkers: 2,
+  cli: "monocode",
+  tasks,
+  continuations: 0,
+  requests: {},
+};
+
+describe("orchestration workspace", () => {
+  it("releases both live and transcript ownership when a lead is deleted", () => {
+    const worker = {
+      ...newSession("claude", "/repo"),
+      orchestrationLeadId: "lead",
+      blocks: [
+        {
+          id: "u",
+          role: "user" as const,
+          text: "Task",
+          orchestrationLeadId: "lead",
+        },
+      ],
+    };
+    const released = releaseOrchestrationWorker(worker, "lead");
+    expect(released.orchestrationLeadId).toBeUndefined();
+    expect(released.blocks[0].orchestrationLeadId).toBeUndefined();
+    expect(released.blocks[0].text).toBe("Task");
+    expect(releaseOrchestrationWorker(worker, "other")).toBe(worker);
+  });
+  it("waits for a slow lead load before opening fast worker transcripts", async () => {
+    const sessions = new Set<string>();
+    let finishLead!: () => void;
+    const host = {
+      openLead: vi.fn(
+        () =>
+          new Promise<void>((resolve) => {
+            finishLead = () => {
+              sessions.add("lead");
+              resolve();
+            };
+          }),
+      ),
+      openWorker: vi.fn(async (id: string) => {
+        sessions.add(id);
+      }),
+      hasSession: (id: string) => sessions.has(id),
+    };
+    const worker = { leadId: "lead", sessionId: "worker-a" };
+    const opening = prepareOrchestrationWorkerDetails([worker], host);
+    await Promise.resolve();
+    expect(host.openWorker).not.toHaveBeenCalled();
+    finishLead();
+    expect(await opening).toEqual({ leadId: "lead", workers: [worker] });
+    expect(host.openWorker).toHaveBeenCalledExactlyOnceWith("worker-a");
+  });
+
+  it("does not publish worker panes when their lead is missing or closed during loading", async () => {
+    const worker = { leadId: "lead", sessionId: "worker-a" };
+    const sessions = new Set<string>();
+    const host = {
+      openLead: vi.fn(async () => {}),
+      openWorker: vi.fn(async () => {
+        sessions.delete("lead");
+      }),
+      hasSession: (id: string) => sessions.has(id),
+    };
+    expect(await prepareOrchestrationWorkerDetails([worker], host)).toBeNull();
+    expect(host.openWorker).not.toHaveBeenCalled();
+    sessions.add("lead");
+    expect(await prepareOrchestrationWorkerDetails([worker], host)).toBeNull();
+  });
+
+  it("folds earlier worker tabs into the lead and moves focus back to it", () => {
+    const tabs = [
+      newTab("lead"),
+      newTab("worker-a"),
+      newTab("worker-b"),
+      newTab("unrelated"),
+    ];
+    const result = consolidateOrchestrationTabs(tabs, tabs[1].id, [run]);
+    expect(result.tabs).toEqual([tabs[0], tabs[3]]);
+    expect(result.activeTabId).toBe(tabs[0].id);
+    expect(
+      consolidateOrchestrationTabs(result.tabs, result.activeTabId, [run]).tabs,
+    ).toBe(result.tabs);
+  });
+  it("keeps unrelated panes when a worker shared a split tab", () => {
+    const lead = newTab("lead");
+    const split = newTab("worker-a");
+    split.layout = splitPane(split.layout, "worker-a", "right", "unrelated");
+    const result = consolidateOrchestrationTabs([lead, split], lead.id, [run]);
+    expect(result.tabs).toHaveLength(2);
+    expect(leafIds(result.tabs[1].layout)).toEqual(["unrelated"]);
+    expect(result.tabs[1].focusedId).toBe("unrelated");
+  });
+  it("retains worker ownership for tabless sessions and leaves other sessions intact", () => {
+    const sessions = ["lead", "worker-a", "worker-b", "unrelated"].map(
+      (id) => ({ ...newSession("claude", "/repo"), id }),
+    );
+    const next = attachOrchestrationWorkers(sessions, [run]);
+    expect(next[0]).toBe(sessions[0]);
+    expect(next[1].orchestrationLeadId).toBe("lead");
+    expect(next[2].orchestrationLeadId).toBe("lead");
+    expect(next[3]).toBe(sessions[3]);
+    expect(attachOrchestrationWorkers(next, [run])).toBe(next);
+  });
+});
diff --git a/src/lib/orchestrationWorkspace.ts b/src/lib/orchestrationWorkspace.ts
new file mode 100644
index 00000000..c849574d
--- /dev/null
+++ b/src/lib/orchestrationWorkspace.ts
@@ -0,0 +1,109 @@
+import { closeLeaf, leafIds, type WorkspaceTab } from "./layout";
+import type { OrchestrationRun } from "./orchestration";
+import type { Session } from "./session";
+
+export function releaseOrchestrationWorker(
+  session: Session,
+  leadId: string,
+): Session {
+  if (
+    session.orchestrationLeadId !== leadId &&
+    !session.blocks.some((block) => block.orchestrationLeadId === leadId)
+  )
+    return session;
+  return {
+    ...session,
+    orchestrationLeadId:
+      session.orchestrationLeadId === leadId
+        ? undefined
+        : session.orchestrationLeadId,
+    blocks: session.blocks.map((block) =>
+      block.orchestrationLeadId === leadId
+        ? { ...block, orchestrationLeadId: undefined }
+        : block,
+    ),
+  };
+}
+
+/** Load the lead first so a fast worker read cannot publish panes without a tab. */
+export async function prepareOrchestrationWorkerDetails<
+  T extends { leadId: string; sessionId: string },
+>(
+  workers: T[],
+  host: {
+    openLead: (id: string) => Promise<void>;
+    openWorker: (id: string) => Promise<unknown>;
+    hasSession: (id: string) => boolean;
+  },
+) {
+  const list = workers.filter(
+    (worker) => worker.leadId && worker.leadId !== worker.sessionId,
+  );
+  if (!list.length) return null;
+  const leadId = list[0].leadId;
+  await host.openLead(leadId);
+  if (!host.hasSession(leadId)) return null;
+  await Promise.all(list.map((worker) => host.openWorker(worker.sessionId)));
+  if (!host.hasSession(leadId)) return null;
+  return {
+    leadId,
+    workers: list.filter((worker) => host.hasSession(worker.sessionId)),
+  };
+}
+
+/**
+ * Adopt worker tabs made by the earlier preview into an already-open lead.
+ * A worker the user asked to inspect is a tab inside an editor pane rather
+ * than a session leaf, so it never reaches this.
+ */
+export function consolidateOrchestrationTabs(
+  tabs: WorkspaceTab[],
+  activeTabId: string,
+  runs: OrchestrationRun[],
+) {
+  const parents = new Map(
+    runs.flatMap((run) =>
+      tabs.some((tab) => leafIds(tab.layout).includes(run.leadId))
+        ? run.tasks.map((task) => [task.sessionId, run.leadId] as const)
+        : [],
+    ),
+  );
+  const active = tabs.find((tab) => tab.id === activeTabId);
+  const lead = active && parents.get(active.focusedId);
+  let changed = false;
+  const next = tabs.flatMap((tab) => {
+    let remaining: WorkspaceTab | null = tab;
+    for (const id of leafIds(tab.layout)) {
+      if (remaining && parents.has(id)) {
+        remaining = closeLeaf(remaining, id);
+        changed = true;
+      }
+    }
+    return remaining ? [remaining] : [];
+  });
+  return {
+    tabs: changed ? next : tabs,
+    activeTabId: lead
+      ? next.find((tab) => leafIds(tab.layout).includes(lead))!.id
+      : activeTabId,
+  };
+}
+
+export function attachOrchestrationWorkers(
+  sessions: Session[],
+  runs: OrchestrationRun[],
+) {
+  const parents = new Map(
+    runs.flatMap((run) =>
+      run.tasks.map((task) => [task.sessionId, run.leadId] as const),
+    ),
+  );
+  let changed = false;
+  const next = sessions.map((session) => {
+    const parent = parents.get(session.id);
+    if (!parent || session.orchestrationLeadId === parent) return session;
+    changed = true;
+    return { ...session, orchestrationLeadId: parent };
+  });
+  return changed ? next : sessions;
+}
diff --git a/src/lib/promptOutline.ts b/src/lib/promptOutline.ts
index 00b50559..b3e99811 100644
--- a/src/lib/promptOutline.ts
+++ b/src/lib/promptOutline.ts
@@ -8,7 +8,7 @@ export type OutlineAnchor = OutlineBand & { id: string };
 export const NEAR_END_PX = 16;
 
 export function promptBlocks(blocks: Block[]): Block[] {
-  return blocks.filter((block) => block.role === "user");
+  return blocks.filter((block) => block.role === "user" && !block.internal);
 }
 
 /**
diff --git a/src/lib/session.ts b/src/lib/session.ts
index 5477fabf..947b1ceb 100644
--- a/src/lib/session.ts
+++ b/src/lib/session.ts
@@ -4,6 +4,7 @@ import type { HandoffComposerCard } from "./handoff";
 import type { InboxComposerCard } from "./githubTasks";
 import type { InboxAskContext } from "./inboxAsk";
 import type { NoteCardMeta, NoteComposerCard } from "./notes";
+import type { OrchestrationProposal } from "./orchestrationPlan";
 import type { LinkedWorkItemUpdateCard } from "./linkedWorkItemActivity";
 import {
   defaultSessionChoice,
@@ -55,7 +56,8 @@ export type TaskListMeta = {
 };
 
 /** One-shot behavior selected in the composer for the next harness turn. */
-export type TurnIntent = "default" | "plan" | "build";
+export type TurnIntent = "default" | "plan" | "build" | "orchestrate";
+export type ComposerTurnOptions = { intent?: TurnIntent };
 
 export type PlanStatus = "streaming" | "ready" | "building" | "built";
 
@@ -232,6 +234,15 @@ export type Block = {
   agentRun?: AgentRunMeta;
   taskList?: TaskListMeta;
   plan?: PlanBlockMeta;
+  orchestration?: OrchestrationProposal;
+  /** Parent conversation for an internal orchestration worker. */
+  orchestrationLeadId?: string;
+  /**
+   * A turn the app wrote on the user's behalf to keep an orchestration moving.
+   * The harness needs it; the transcript hides it, so a run reads as one
+   * conversation rather than the user narrating their own agents.
+   */
+  internal?: boolean;
   handoff?: HandoffMeta;
   secondOpinion?: SecondOpinionMeta;
   /** Note chip shown on this user turn. Body is not stored; the harness already received it. */
@@ -275,6 +286,8 @@ export const RUNTIME_MODE_HINT: Record<RuntimeMode, string> = {
 };
 
 export type Session = {
+  /** Internal worker: displayed in its lead's panel rather than a workspace tab. */
+  orchestrationLeadId?: string;
   /** Temporary Inbox conversation: shares the runtime, never saved as a session. */
   inboxAsk?: InboxAskContext;
   id: string;
diff --git a/src/lib/sessionHistory.test.ts b/src/lib/sessionHistory.test.ts
index 7a8505e3..65647470 100644
--- a/src/lib/sessionHistory.test.ts
+++ b/src/lib/sessionHistory.test.ts
@@ -9,12 +9,9 @@ import {
 } from "./sessionHistory";
 import { newSession } from "./session";
 import type { SessionSummary } from "./sessionStore";
+import type { OrchestrationRun } from "./orchestration";
 
-function summary(
-  id: string,
-  cwd: string,
-  updatedAt = 1,
-): SessionSummary {
+function summary(id: string, cwd: string, updatedAt = 1): SessionSummary {
   return {
     id,
     cwd,
@@ -30,6 +27,93 @@ function summary(
 }
 
 describe("historyWithLiveSessions", () => {
+  const run: OrchestrationRun = {
+    version: 1,
+    leadId: "lead",
+    cwd: "/tmp/project-a",
+    status: "active",
+    allowedHarnesses: ["codex"],
+    maxWorkers: 2,
+    cli: "monocode",
+    continuations: 0,
+    requests: {},
+    tasks: ["worker-a", "worker-b"].map((id) => ({
+      id,
+      sessionId: id,
+      title: id,
+      harness: "codex",
+      model: "codex:test",
+      prompt: "Task",
+      files: [id],
+      scopes: [id],
+      dependsOn: [],
+      status: "running",
+      accepted: false,
+      result: "",
+      delivered: false,
+    })),
+  };
+
+  it("groups live and already-saved workers under their lead before adoption effects run", () => {
+    const sessions = ["lead", "worker-a", "worker-b"].map((id) => ({
+      ...newSession("codex", run.cwd),
+      id,
+      blocks: [{ id: "u", role: "user" as const, text: "Build" }],
+      busy: id !== "lead",
+    }));
+    const rows = historyWithLiveSessions(
+      [
+        summary("lead", run.cwd),
+        summary("worker-a", run.cwd),
+        summary("unrelated", run.cwd),
+      ],
+      sessions,
+      run.cwd,
+      undefined,
+      [run],
+    );
+    expect(rows.map((row) => row.id).sort()).toEqual(["lead", "unrelated"]);
+    expect(rows.find((row) => row.id === "lead")?.orchestration).toMatchObject({
+      live: true,
+      status: "active",
+      tasks: [{ sessionId: "worker-a" }, { sessionId: "worker-b" }],
+    });
+  });
+
+  it("keeps ownership after restart, cache merges, and replacement runs", () => {
+    const history: SessionSummary[] = [
+      {
+        ...summary("lead", run.cwd),
+        orchestration: { status: "paused", tasks: run.tasks },
+      },
+      summary("worker-a", run.cwd),
+      { ...summary("older-worker", run.cwd), orchestrationLeadId: "lead" },
+    ];
+    const merged = mergeHistorySummary(history, summary("lead", run.cwd, 2));
+    const rows = historyWithLiveSessions(merged, [], run.cwd);
+    expect(rows.map((row) => row.id)).toEqual(["lead"]);
+    expect(rows[0].orchestration?.tasks).toHaveLength(2);
+    const replacement = historyWithLiveSessions(
+      merged,
+      [],
+      run.cwd,
+      undefined,
+      [{ ...run, tasks: [] }],
+    );
+    expect(replacement.map((row) => row.id)).toEqual(["lead"]);
+    expect(replacement[0].orchestration?.tasks).toEqual([]);
+  });
+
+  it("does not inject an internal worker without a loaded run", () => {
+    const worker = {
+      ...newSession("codex", run.cwd),
+      id: "worker",
+      orchestrationLeadId: "lead",
+      busy: true,
+    };
+    expect(historyWithLiveSessions([], [worker], run.cwd)).toEqual([]);
+  });
+
   it("drops persisted sessions from other projects", () => {
     const history = [
       summary("a1", "/tmp/project-a"),
@@ -105,12 +189,10 @@ describe("historyWithLiveSessions", () => {
     session.busy = true;
     session.branch = "feat/picker";
 
-    const rows = historyWithLiveSessions(
-      [],
-      [session],
-      "/tmp/agent-terminal",
-      { repo: "monocode", branch: "main" },
-    );
+    const rows = historyWithLiveSessions([], [session], "/tmp/agent-terminal", {
+      repo: "monocode",
+      branch: "main",
+    });
     expect(rows[0]).toMatchObject({
       id: session.id,
       repo: "monocode",
@@ -162,12 +244,18 @@ describe("filterSessionsByQuery", () => {
 
   it("matches conversation titles", () => {
     const rows = [
-      { ...summary("a1", "/tmp/project-a"), title: "cursor · Fix sidebar search" },
-      { ...summary("a2", "/tmp/project-a"), title: "cursor · Archive sessions" },
+      {
+        ...summary("a1", "/tmp/project-a"),
+        title: "cursor · Fix sidebar search",
+      },
+      {
+        ...summary("a2", "/tmp/project-a"),
+        title: "cursor · Archive sessions",
+      },
     ];
-    expect(filterSessionsByQuery(rows, "sidebar").map((row) => row.id)).toEqual([
-      "a1",
-    ]);
+    expect(filterSessionsByQuery(rows, "sidebar").map((row) => row.id)).toEqual(
+      ["a1"],
+    );
   });
 
   it("matches model and branch labels", () => {
@@ -252,9 +340,7 @@ describe("pinned sessions", () => {
   });
 
   it("preserves pin when an incoming summary omits it", () => {
-    const current = [
-      { ...summary("pin", "/tmp/project-a", 5), pinned: true },
-    ];
+    const current = [{ ...summary("pin", "/tmp/project-a", 5), pinned: true }];
     const next = mergeHistorySummary(
       current,
       summary("pin", "/tmp/project-a", 9),
diff --git a/src/lib/sessionHistory.ts b/src/lib/sessionHistory.ts
index 59fffd7d..149283c6 100644
--- a/src/lib/sessionHistory.ts
+++ b/src/lib/sessionHistory.ts
@@ -1,7 +1,13 @@
+import type { OrchestrationRun } from "./orchestration";
+import { summarizeOrchestration } from "./orchestrationSummary";
 import { fuzzyMatch } from "./fuzzy";
 import { projectName } from "./paths";
 import { sameProjectPath } from "./recents";
-import { sessionDisplayTitle, sessionNeedsInput, type Session } from "./session";
+import {
+  sessionDisplayTitle,
+  sessionNeedsInput,
+  type Session,
+} from "./session";
 import { shouldPersistSession, type SessionSummary } from "./sessionStore";
 
 export type SessionGitHint = {
@@ -27,6 +33,9 @@ export function mergeHistorySummary(
     ...summary,
     archived: summary.archived ?? previous?.archived,
     pinned: summary.pinned ?? previous?.pinned,
+    orchestration: summary.orchestration ?? previous?.orchestration,
+    orchestrationLeadId:
+      summary.orchestrationLeadId ?? previous?.orchestrationLeadId,
   };
   return [next, ...current.filter((entry) => entry.id !== summary.id)].sort(
     compareSessionSummaries,
@@ -95,6 +104,7 @@ export function summaryFromSession(
 ): SessionSummary {
   return {
     id: session.id,
+    orchestrationLeadId: session.orchestrationLeadId,
     cwd: session.cwd,
     harness: session.harness,
     model: session.model,
@@ -137,12 +147,30 @@ export function historyWithLiveSessions(
   sessions: Session[],
   cwd: string,
   git?: SessionGitHint,
+  runs: readonly OrchestrationRun[] = [],
 ): SessionSummary[] {
-  const inboxIds = new Set(sessions.filter(session => session.inboxAsk).map(session => session.id));
-  let rows = history.filter((entry) => !inboxIds.has(entry.id) && sameProjectPath(entry.cwd, cwd));
+  const workerIds = new Set([
+    ...sessions
+      .filter((session) => session.orchestrationLeadId)
+      .map((session) => session.id),
+    ...history.flatMap(
+      (row) => row.orchestration?.tasks.map((task) => task.sessionId) ?? [],
+    ),
+    ...runs.flatMap((run) => run.tasks.map((task) => task.sessionId)),
+  ]);
+  const inboxIds = new Set(
+    sessions.filter((session) => session.inboxAsk).map((session) => session.id),
+  );
+  let rows = history.filter(
+    (entry) =>
+      !inboxIds.has(entry.id) &&
+      !entry.orchestrationLeadId &&
+      !workerIds.has(entry.id) &&
+      sameProjectPath(entry.cwd, cwd),
+  );
   const hint = projectGitHint(rows, gitOverlayForCwd(cwd, git));
   for (const session of sessions) {
-    if (session.inboxAsk) continue;
+    if (session.inboxAsk || workerIds.has(session.id)) continue;
     if (!sameProjectPath(session.cwd, cwd)) continue;
     const live = session.busy || sessionNeedsInput(session);
     if (!shouldPersistSession(session) && !live) continue;
@@ -153,5 +181,13 @@ export function historyWithLiveSessions(
     };
     rows = mergeHistorySummary(rows, summaryFromSession(session, sessionHint));
   }
-  return [...rows].sort(compareSessionSummaries);
+  const byLead = new Map(runs.map((run) => [run.leadId, run]));
+  return rows
+    .map((row) => {
+      const run = byLead.get(row.id);
+      return run
+        ? { ...row, orchestration: summarizeOrchestration(run, sessions) }
+        : row;
+    })
+    .sort(compareSessionSummaries);
 }
diff --git a/src/lib/sessionStore.test.ts b/src/lib/sessionStore.test.ts
index a762b648..29755152 100644
--- a/src/lib/sessionStore.test.ts
+++ b/src/lib/sessionStore.test.ts
@@ -92,6 +92,35 @@ describe("persisting a subagent's trail", () => {
 });
 
 describe("sanitizeSessionForPersist", () => {
+  it("preserves an internal worker's lead, hidden turns, and token metrics", () => {
+    const session = {
+      ...newSession("claude", "/repo"),
+      orchestrationLeadId: "lead",
+    };
+    session.blocks = [
+      {
+        id: "u",
+        role: "user",
+        text: "Bounded assignment",
+        internal: true,
+        turnMetrics: { inputTokens: 100, outputTokens: 20 },
+      },
+    ];
+    const saved = sanitizeSessionForPersist(session);
+    expect(saved.blocks[0]).toMatchObject({
+      orchestrationLeadId: "lead",
+      internal: true,
+      turnMetrics: { inputTokens: 100, outputTokens: 20 },
+    });
+    expect(session.blocks[0].orchestrationLeadId).toBeUndefined();
+    expect(
+      sanitizeSessionForPersist({
+        ...session,
+        orchestrationLeadId: undefined,
+        blocks: saved.blocks,
+      }).blocks[0],
+    ).toEqual(saved.blocks[0]);
+  });
   it("persists model provenance recorded on a user turn", () => {
     const session = newSession("claude", "/tmp/project", "claude:opus-5");
     session.blocks = [
diff --git a/src/lib/sessionStore.ts b/src/lib/sessionStore.ts
index ae9170da..2d80f896 100644
--- a/src/lib/sessionStore.ts
+++ b/src/lib/sessionStore.ts
@@ -23,8 +23,13 @@ import type {
   TurnMetrics,
 } from "./session";
 import { HARNESSES, RUNTIME_MODES } from "./session";
+import { restoreOrchestrationProposal } from "./orchestrationPlan";
+
+import type { OrchestrationSummary } from "./orchestrationSummary";
 
 export type SessionSummary = {
+  orchestrationLeadId?: string;
+  orchestration?: OrchestrationSummary;
   id: string;
   cwd: string;
   harness: HarnessId;
@@ -44,6 +49,7 @@ export type SessionSummary = {
 };
 
 type SessionRecord = {
+  orchestrationLeadId?: string;
   id: string;
   cwd: string;
   harness: string;
@@ -148,10 +154,17 @@ export function sanitizeLinkedWorkItem(
 export function sanitizeSessionForPersist(
   session: Session,
 ): SessionUpsertPayload {
+  const firstUser = session.blocks.findIndex((block) => block.role === "user");
   return {
     ...persistableMeta(session),
     blocks: session.blocks
-      .map(sanitizeBlock)
+      .map((block, index) =>
+        sanitizeBlock(
+          index === firstUser && session.orchestrationLeadId
+            ? { ...block, orchestrationLeadId: session.orchestrationLeadId }
+            : block,
+        ),
+      )
       .filter((block): block is Block => block != null),
   };
 }
@@ -193,7 +206,17 @@ export async function upsertSession(
   const payload = sanitizeSessionForPersist(session);
   const summary = await enqueueSessionWrite(session.id, async () => {
     if (deletedSessionIds.has(session.id)) return null;
-    return invoke<SessionSummary>("session_upsert", { session: payload });
+    return invoke<SessionSummary>("session_upsert", {
+      session: {
+        ...payload,
+        blocks: payload.blocks.map((block) =>
+          block.orchestrationLeadId &&
+          deletedSessionIds.has(block.orchestrationLeadId)
+            ? { ...block, orchestrationLeadId: undefined }
+            : block,
+        ),
+      },
+    });
   });
   return summary ? normalizeSummary(summary) : null;
 }
@@ -217,7 +240,7 @@ function blockToken(block: Block): number {
 }
 
 export function persistFingerprint(session: Session): string {
-  return `${JSON.stringify(persistableMeta(session))}|${session.blocks
+  return `${JSON.stringify(persistableMeta(session))}|${session.orchestrationLeadId ?? ""}|${session.blocks
     .map(blockToken)
     .join(",")}`;
 }
@@ -309,6 +332,9 @@ export async function getSession(sessionId: string): Promise<Session | null> {
 export async function deleteSession(sessionId: string): Promise<void> {
   deletedSessionIds.add(sessionId);
   try {
+    // A lead's workers may still have writes in flight. Finish those before
+    // the deletion transaction strips their ownership metadata.
+    await Promise.all([...sessionWriteQueues.values()]);
     await enqueueSessionWrite(sessionId, () =>
       invoke<void>("session_delete", { sessionId }),
     );
@@ -409,6 +435,15 @@ function sanitizeBlock(block: Block): Block | null {
   if (block.durationMs != null) next.durationMs = block.durationMs;
   const turnModel = sanitizeTurnModel(block.turnModel);
   if (block.role === "user" && turnModel) next.turnModel = turnModel;
+  if (
+    block.role === "user" &&
+    typeof block.orchestrationLeadId === "string" &&
+    isPersistableId(block.orchestrationLeadId)
+  )
+    next.orchestrationLeadId = block.orchestrationLeadId;
+  // Without this the transcript would show the app's orchestration turns as
+  // the user's own after a reload.
+  if (block.role === "user" && block.internal) next.internal = true;
   const turnMetrics = sanitizeTurnMetrics(block.turnMetrics);
   if (block.role === "user" && turnMetrics) next.turnMetrics = turnMetrics;
   if (block.tool) next.tool = block.tool;
@@ -427,6 +462,8 @@ function sanitizeBlock(block: Block): Block | null {
   if (taskList) next.taskList = taskList;
   else if (block.role === "tasks") return null;
   const plan = sanitizePlan(block.plan, block.text);
+  if (block.orchestration)
+    next.orchestration = restoreOrchestrationProposal(block.orchestration);
   if (plan) next.plan = plan;
   else if (block.role === "plan") {
     next.plan = { status: "ready", originalText: block.text };
@@ -673,6 +710,10 @@ function recordToSession(record: SessionRecord): Session {
     title: record.title,
     blocks,
     busy: false,
+    orchestrationLeadId: record.orchestrationLeadId ?? blocks.find(
+      (block) =>
+        block.orchestrationLeadId && block.orchestrationLeadId !== record.id,
+    )?.orchestrationLeadId,
     ...(record.providerSessionId
       ? { providerSessionId: record.providerSessionId }
       : {}),
diff --git a/src/lib/sessionStoreConcurrency.test.ts b/src/lib/sessionStoreConcurrency.test.ts
index ece0fd4b..96da414c 100644
--- a/src/lib/sessionStoreConcurrency.test.ts
+++ b/src/lib/sessionStoreConcurrency.test.ts
@@ -41,6 +41,37 @@ afterEach(() => {
 });
 
 describe("session persistence concurrency", () => {
+  it("drains worker writes before deleting a lead and strips ownership from later snapshots", async () => {
+    const firstWrite = deferred<unknown>();
+    const commands: string[] = [];
+    mocks.invoke.mockImplementation((command: string) => {
+      commands.push(command);
+      return command === "session_upsert" && commands.length === 1
+        ? firstWrite.promise
+        : Promise.resolve();
+    });
+    const { deleteSession, upsertSession } = await loadStore();
+    const worker = { ...session("worker"), orchestrationLeadId: "lead" };
+    const writing = upsertSession(worker);
+    await vi.waitFor(() => expect(commands).toEqual(["session_upsert"]));
+    const queued = upsertSession(worker);
+    const deleting = deleteSession("lead");
+    expect(commands).toEqual(["session_upsert"]);
+    firstWrite.resolve(undefined);
+    await Promise.all([writing, queued, deleting]);
+    expect(commands).toEqual([
+      "session_upsert",
+      "session_upsert",
+      "session_delete",
+    ]);
+    await upsertSession(worker);
+    for (const [, args] of mocks.invoke.mock.calls
+      .slice(1)
+      .filter(([command]) => command === "session_upsert")) {
+      expect(args.session.blocks[0].orchestrationLeadId).toBeUndefined();
+    }
+  });
+
   it("serializes deletion after an active write and drops a queued late upsert", async () => {
     const firstWrite = deferred<unknown>();
     const commands: string[] = [];
diff --git a/src/lib/workspaceSnapshot.test.ts b/src/lib/workspaceSnapshot.test.ts
index f762da53..93e8b689 100644
--- a/src/lib/workspaceSnapshot.test.ts
+++ b/src/lib/workspaceSnapshot.test.ts
@@ -2,6 +2,8 @@ import { describe, expect, it } from "vitest";
 import { INTERRUPT_MESSAGE } from "./inFlight";
 import {
   leaf,
+  leafIds,
+  newAgentTab,
   newChangesTab,
   newCommitTab,
   newFileTab,
@@ -9,6 +11,7 @@ import {
   newSessionChangesTab,
   newTab,
   newTerminalFile,
+  splitPane,
 } from "./layout";
 import { createProjectTerminal } from "./projectTerminal";
 import { newSession, type Session } from "./session";
@@ -177,6 +180,45 @@ describe("collectWorkspaceSnapshot", () => {
     expect(snapshot.projectTerminals).toEqual([]);
   });
 
+  it("drops agent tabs, and the pane holding only them", () => {
+    const file = newFileTab("/tmp/a/README.md", "/tmp/a");
+    const agent = newAgentTab("Audit the UI", "/tmp/a", {
+      sessionId: "worker",
+      leadId: "s1",
+      harness: "codex",
+    });
+    const mixed = newAgentTab("Audit the engine", "/tmp/a", {
+      sessionId: "worker-2",
+      leadId: "s1",
+      harness: "codex",
+    });
+    const tab = {
+      ...newTab("s1"),
+      id: "t1",
+      layout: splitPane(newTab("s1").layout, "s1", "right", "e1"),
+      editorPanes: [
+        { id: "e1", files: [agent], activeFileId: agent.id },
+        { id: "e2", files: [file, mixed], activeFileId: mixed.id },
+      ],
+    };
+    const snapshot = collectWorkspaceSnapshot(
+      [tab],
+      [],
+      "t1",
+      "/tmp/a",
+      new Map(),
+    );
+    const panes = snapshot.tabs[0]!.editorPanes;
+    // The agent-only pane is gone along with its leaf; the mixed one keeps its
+    // file and falls back to it as the active tab.
+    expect(panes.map((pane) => pane.id)).toEqual(["e2"]);
+    expect(panes[0]!.files.map((entry) => entry.path)).toEqual([
+      "/tmp/a/README.md",
+    ]);
+    expect(panes[0]!.activeFileId).toBe(file.id);
+    expect(leafIds(snapshot.tabs[0]!.layout)).toEqual(["s1"]);
+  });
+
   it("round-trips a unified Changes tab", () => {
     const file = newChangesTab("/tmp/a", "/tmp/a/src/lib.rs", "staged");
     const tab = {
diff --git a/src/lib/workspaceSnapshot.ts b/src/lib/workspaceSnapshot.ts
index 250403a2..22ac57ac 100644
--- a/src/lib/workspaceSnapshot.ts
+++ b/src/lib/workspaceSnapshot.ts
@@ -1,6 +1,7 @@
 import { markTurnInterrupted, type ResumedWorkspace } from "./inFlight";
 import {
   closeLeaf,
+  isAgentTab,
   isTerminalTab,
   leafIds,
   newTab,
@@ -63,7 +64,7 @@ export function collectWorkspaceSnapshot(
   projectTerminals: ProjectTerminalDock[] = [],
 ): WorkspaceSnapshot {
   const snapshot = withoutInboxSessions({
-    tabs: tabs.map(sanitizeTab).filter((tab): tab is WorkspaceTab => tab != null),
+    tabs: withoutAgentTabs(tabs).map(sanitizeTab).filter((tab): tab is WorkspaceTab => tab != null),
     sessions: sessions.map(sessionStub).filter((stub): stub is WorkspaceSessionStub => stub != null),
     activeTabId,
     projectCwd: projectCwd.trim() || "~",
@@ -111,6 +112,36 @@ function parseProjectReturnTargets(raw: unknown): ProjectReturnMemory {
   return memory;
 }
 
+/**
+ * Agent tabs watch a live worker, and a run does not outlive the window that
+ * started it. Dropping them in `sanitizeFile` would strand an empty pane and
+ * cost the whole workspace tab on restore, so the pane is closed here instead.
+ */
+function withoutAgentTabs(tabs: WorkspaceTab[]): WorkspaceTab[] {
+  return tabs.flatMap(tab => {
+    if (!tab.editorPanes.some(pane => pane.files.some(isAgentTab))) return [tab];
+    let remaining: WorkspaceTab | null = tab;
+    const panes: EditorPane[] = [];
+    for (const pane of tab.editorPanes) {
+      const files = pane.files.filter(file => !isAgentTab(file));
+      if (files.length === pane.files.length) {
+        panes.push(pane);
+      } else if (files.length === 0) {
+        remaining = remaining && closeLeaf(remaining, pane.id);
+      } else {
+        panes.push({
+          ...pane,
+          files,
+          activeFileId: files.some(file => file.id === pane.activeFileId)
+            ? pane.activeFileId
+            : files[0].id,
+        });
+      }
+    }
+    return remaining ? [{ ...remaining, editorPanes: panes }] : [];
+  });
+}
+
 /** Also removes tabs saved by the earlier, persistent Inbox implementation. */
 function withoutInboxSessions(snapshot: WorkspaceSnapshot): WorkspaceSnapshot {
   const inboxIds = snapshot.sessions.filter(session => session.inboxAsk).map(session => session.id);
diff --git a/src/surfaces/AgentTabView.tsx b/src/surfaces/AgentTabView.tsx
new file mode 100644
index 00000000..5625bfad
--- /dev/null
+++ b/src/surfaces/AgentTabView.tsx
@@ -0,0 +1,61 @@
+import { AgentTranscript } from "./AgentTranscript";
+import { HarnessIcon } from "../chrome/HarnessIcon";
+import { findModel } from "../lib/models";
+import { HARNESS_TITLE, sessionWorkCwd, type Session } from "../lib/session";
+
+/**
+ * One orchestration worker, watched from its lead's workspace.
+ *
+ * Read-only on purpose: the run belongs to the orchestrator, which decides
+ * what each worker is asked and when. A composer here would put a second
+ * voice into a conversation the lead is holding, so the way to change course
+ * is to say so in the lead's own transcript.
+ */
+export function AgentTabView({
+  title,
+  session,
+  visible,
+  onOpenFile,
+}: {
+  title: string;
+  session?: Session;
+  visible: boolean;
+  onOpenFile?: (path: string) => void;
+}) {
+  if (!session) {
+    return (
+      <div className="grid h-full place-items-center px-6 text-center">
+        <p className="max-w-sm text-[12px] leading-5 text-content/45">
+          This agent is no longer running. Its work is summarised in the
+          orchestrator's conversation.
+        </p>
+      </div>
+    );
+  }
+  const model = findModel(session.model)?.name ?? session.model;
+  return (
+    <div className="flex h-full min-h-0 flex-col">
+      <div className="min-h-0 flex-1">
+        <AgentTranscript
+          blocks={session.blocks}
+          busy={session.busy}
+          cwd={sessionWorkCwd(session)}
+          harness={session.harness}
+          model={session.model}
+          visible={visible}
+          onOpenFile={onOpenFile}
+          managed
+        />
+      </div>
+      <footer className="flex shrink-0 items-center gap-1.5 border-t border-content/10 px-3 py-1.5 font-sans text-[11px] text-content/45">
+        <HarnessIcon harness={session.harness} className="size-3.5 shrink-0" />
+        <span className="min-w-0 truncate" title={title}>
+          {model} · {HARNESS_TITLE[session.harness]}
+        </span>
+        <span className="ml-auto shrink-0">
+          Run by the orchestrator · read-only
+        </span>
+      </footer>
+    </div>
+  );
+}
diff --git a/src/surfaces/AgentTranscript.test.ts b/src/surfaces/AgentTranscript.test.ts
index 7088bb62..e3c2d88c 100644
--- a/src/surfaces/AgentTranscript.test.ts
+++ b/src/surfaces/AgentTranscript.test.ts
@@ -25,6 +25,57 @@ function render(
 }
 
 describe("AgentTranscript collapsed work", () => {
+  it("reveals an orchestration result after the finished turn and before its action row", () => {
+    const card: Block = {
+      id: "proposal",
+      role: "plan",
+      text: "Assignment plan",
+      orchestration: {
+        version: 1,
+        leadId: "lead",
+        cwd: "/repo",
+        request: "Build",
+        author: { harness: "claude", model: "claude:test", name: "Lead" },
+        settings: {
+          choices: [
+            { harness: "claude", model: "claude:test", name: "Worker" },
+          ],
+          maxWorkers: 2,
+        },
+        status: "ready",
+        title: "Proposed assignments",
+        summary: "Implement and verify",
+        tasks: [],
+      },
+    };
+    const blocks: Block[] = [
+      {
+        id: "user",
+        role: "user",
+        text: "Build",
+        startedAt: 1000,
+        durationMs: 500,
+      },
+      card, // Existing records have the card before the work.
+      tool("inspection"),
+      {
+        id: "answer",
+        role: "assistant",
+        text: "The investigation is complete.",
+      },
+    ];
+    expect(render(blocks, true)).not.toContain("data-orchestration-review");
+    const finished = render(blocks);
+    expect(finished.indexOf("The investigation is complete.")).toBeLessThan(
+      finished.indexOf("data-orchestration-result"),
+    );
+    expect(finished.indexOf("data-orchestration-review")).toBeLessThan(
+      finished.indexOf('aria-label="Worked for 1s"'),
+    );
+    expect(finished.match(/data-orchestration-review/g)).toHaveLength(1);
+    card.orchestration!.status = "planning";
+    expect(render(blocks)).not.toContain("data-orchestration-review");
+  });
   it("renders a standalone user URL as a compact link preview", () => {
     const markup = render([
       { id: "user", role: "user", text: "https://www.example.com/docs" },
@@ -374,3 +425,26 @@ describe("AgentTranscript collapsed work", () => {
     expect(markup).toContain("Checked.");
   });
 });
+
+describe("worker assignment prompts", () => {
+  it("hides the assignment envelope and keeps the task text", () => {
+    const markup = renderToStaticMarkup(
+      createElement(AgentTranscript, {
+        managed: true,
+        blocks: [
+          {
+            id: "u1",
+            role: "user",
+            internal: true,
+            text: "Review the current branch against main.\n\n<monocode_assignment>\nYou are a worker managed by a MonoCode lead. Your assigned write scope is: src/App.tsx.\n</monocode_assignment>",
+          },
+          { id: "a1", role: "assistant", text: "Looking now" },
+        ],
+      }),
+    );
+    expect(markup).toContain("Review the current branch against main.");
+    expect(markup).toContain("Looking now");
+    expect(markup).not.toContain("monocode_assignment");
+    expect(markup).not.toContain("You are a worker managed by a MonoCode lead");
+  });
+});
diff --git a/src/surfaces/AgentTranscript.tsx b/src/surfaces/AgentTranscript.tsx
index 10a64c88..83cbeca1 100644
--- a/src/surfaces/AgentTranscript.tsx
+++ b/src/surfaces/AgentTranscript.tsx
@@ -29,6 +29,7 @@ import { FilePreview } from "../chrome/FilePreview";
 import { FileTypeIcon } from "../chrome/FileTypeIcon";
 import { ToolDiffPreview } from "../chrome/ToolDiffPreview";
 import { PlanPreview } from "../chrome/PlanPreview";
+import { OrchestrationPreview } from "../chrome/OrchestrationPreview";
 import { TaskListPreview } from "../chrome/TaskListPreview";
 import {
   HandoffButton,
@@ -47,6 +48,7 @@ import {
   stubFilePreview,
 } from "../lib/harness/preview";
 import { copyText } from "../lib/clipboard";
+import { visibleUserPrompt } from "../lib/orchestration";
 import { playCue } from "../lib/sounds";
 import { legacyTaskListFromText } from "../lib/taskList";
 import { displayPath, resolveWorkspacePath } from "../lib/paths";
@@ -135,6 +137,8 @@ type Props = {
   latestTurnAccessory?: ReactNode;
   /** False while another tab is in front; local transcript state is retained. */
   visible?: boolean;
+  /** A worker's transcript: show the orchestrator's turns instead of hiding them. */
+  managed?: boolean;
 };
 
 function AgentTranscriptComponent({
@@ -159,6 +163,7 @@ function AgentTranscriptComponent({
   onRevealReady,
   latestTurnAccessory,
   visible = true,
+  managed = false,
 }: Props) {
   const lockOverscroll = useLockOverscroll<HTMLDivElement>();
   const scroller = useRef<HTMLDivElement>(null);
@@ -184,7 +189,7 @@ function AgentTranscriptComponent({
   );
   const transcriptLayout = useTranscriptLayout();
   const promptAnchor = useTranscriptAnchor();
-  const lastUserId = lastUserBlockId(blocks);
+  const lastUserId = lastUserBlockId(blocks, managed);
   const seenUserId = useRef(lastUserId);
   if (lastUserId !== seenUserId.current) {
     seenUserId.current = lastUserId;
@@ -312,7 +317,7 @@ function AgentTranscriptComponent({
     return () => observer.disconnect();
   }, [scrollerEl, setShowJump, visible]);
 
-  const turns = groupTurns(blocks);
+  const turns = groupTurns(blocks, managed);
   const firstVisibleTurn = Math.max(0, turns.length - visibleTurnCount);
   const visibleTurns = turns.slice(firstVisibleTurn);
   const turnsRef = useRef(turns);
@@ -383,10 +388,15 @@ function AgentTranscriptComponent({
         ) : null}
         {visibleTurns.map((turn, turnIndex) => {
           const isLastTurn = firstVisibleTurn + turnIndex === turns.length - 1;
-          const userBlock = turnUserBlock(turn);
+          const userBlock = turnUserBlock(turn, managed);
           const durationMs = userBlock?.durationMs;
           const settled = !(busy && isLastTurn);
-          const items = groupTurnItems(turn);
+          const proposals = turn.filter((block) => block.orchestration);
+          // Proposals are turn results, like the changes card. Keep them out
+          // of the live work and append them after all of the lead's output.
+          const items = groupTurnItems(
+            turn.filter((block) => !block.orchestration),
+          );
           // Earlier activity groups have already been followed by prose or
           // more work. Only the last one can still be the live group.
           const foldedAt = lastActivityIndex(items);
@@ -508,12 +518,10 @@ function AgentTranscriptComponent({
           // do not collapse with it: they are lifted out and parked under the
           // work, where they stay put however often it re-folds.
           const foldEntries = fold
-            ? items
-                .slice(fold.start, fold.end + 1)
-                .map((entry, offset) => ({
-                  entry,
-                  index: fold.start + offset,
-                }))
+            ? items.slice(fold.start, fold.end + 1).map((entry, offset) => ({
+                entry,
+                index: fold.start + offset,
+              }))
             : [];
           const foldSubagents = foldEntries.filter(
             ({ entry }) => entry.type === "subagents",
@@ -588,6 +596,18 @@ function AgentTranscriptComponent({
                 return [foldLineRow, row];
               })}
               {foldLineAt >= items.length ? foldLineRow : null}
+              {settled &&
+                proposals
+                  .filter((block) => block.orchestration?.status !== "planning")
+                  .map((block) => (
+                    <div
+                      key={block.id}
+                      className="px-4 pt-1 pb-2"
+                      data-orchestration-result
+                    >
+                      <OrchestrationPreview block={block} busy={!!busy} />
+                    </div>
+                  ))}
               {isLastTurn && latestTurnAccessory ? latestTurnAccessory : null}
               {durationMs != null && settled ? (
                 <TurnDuration
@@ -806,7 +826,7 @@ function TurnMetricsBadge({
   return (
     <div
       ref={root}
-      className="relative shrink-0"
+      className="relative shrink-0 pl-1"
       onMouseEnter={() => setHovered(true)}
       onMouseLeave={() => setHovered(false)}
       onFocus={() => setHovered(true)}
@@ -1012,6 +1032,7 @@ const TranscriptBlock = memo(function TranscriptBlock({
   }
 
   if (block.role === "plan") {
+    if (block.orchestration) return null;
     const legacyTasks = legacyTaskListFromText(block.text);
     if (legacyTasks) {
       return (
@@ -1099,7 +1120,8 @@ function UserMessageBlock({
   const textRef = useRef<HTMLElement>(null);
   const card = block.secondOpinion;
   const note = block.noteCard;
-  const text = card && card.kind !== "handoff" ? "" : block.text;
+  const text =
+    card && card.kind !== "handoff" ? "" : visibleUserPrompt(block.text);
   const messageLink = text ? parseUserMessageLink(text) : null;
   const displayText = messageLink
     ? `${messageLink.beforeText}${messageLink.afterText}`
@@ -2767,13 +2789,14 @@ function InterjectionDivider({ block }: { block: Block }) {
   );
 }
 
-function lastUserBlockId(blocks: Block[]): string | undefined {
-  return turnUserBlock(blocks)?.id;
+function lastUserBlockId(blocks: Block[], managed = false): string | undefined {
+  return turnUserBlock(blocks, managed)?.id;
 }
 
-function turnUserBlock(blocks: Block[]): Block | undefined {
+function turnUserBlock(blocks: Block[], managed = false): Block | undefined {
   for (let i = blocks.length - 1; i >= 0; i--) {
-    if (blocks[i].role === "user") return blocks[i];
+    const block = blocks[i];
+    if (block.role === "user" && (managed || !block.internal)) return block;
   }
   return undefined;
 }
diff --git a/src/surfaces/FilePane.agent.test.ts b/src/surfaces/FilePane.agent.test.ts
new file mode 100644
index 00000000..81130868
--- /dev/null
+++ b/src/surfaces/FilePane.agent.test.ts
@@ -0,0 +1,95 @@
+// @vitest-environment happy-dom
+import { act, createElement, type ComponentProps } from "react";
+import { createRoot, type Root } from "react-dom/client";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { newAgentTab, newEditorPane } from "../lib/layout";
+import { newSession } from "../lib/session";
+import { FilePane } from "./FilePane";
+
+vi.mock("@tauri-apps/api/core", () => ({
+  invoke: vi.fn(async () => []),
+  isTauri: () => false,
+  convertFileSrc: (path: string) => path,
+}));
+vi.mock("@tauri-apps/api/event", () => ({ listen: async () => () => {} }));
+
+describe("file pane agent tabs", () => {
+  let root: Root;
+  let container: HTMLDivElement;
+  let props: ComponentProps<typeof FilePane>;
+
+  beforeEach(() => {
+    vi.stubGlobal("IS_REACT_ACT_ENVIRONMENT", true);
+    container = document.createElement("div");
+    document.body.append(container);
+    root = createRoot(container);
+    const file = newAgentTab("Audit the engine", "/repo", {
+      sessionId: "worker",
+      leadId: "lead",
+      harness: "codex",
+    });
+    const noop = () => {};
+    props = {
+      pane: newEditorPane(file),
+      focused: true,
+      dirtyFileIds: new Set(),
+      fileErrorCounts: new Map(),
+      sessions: [],
+      onFocus: noop,
+      onSelectFile: noop,
+      onCloseFile: noop,
+      onCloseOtherFiles: noop,
+      onDirtyChange: noop,
+      onErrorCountChange: noop,
+      onReorderFiles: noop,
+      onOpenFile: noop,
+      onUpdatePlan: noop,
+      onBuildPlan: noop,
+    };
+  });
+
+  afterEach(async () => {
+    await act(async () => root.unmount());
+    container.remove();
+    vi.unstubAllGlobals();
+  });
+
+  it("shows a worker transcript after its session arrives", async () => {
+    await act(async () => root.render(createElement(FilePane, props)));
+    expect(container.textContent).toContain("This agent is no longer running");
+
+    const session = {
+      ...newSession("codex", "/repo"),
+      id: "worker",
+      blocks: [
+        { id: "u1", role: "user" as const, text: "Audit the engine" },
+        { id: "a1", role: "assistant" as const, text: "Looking now" },
+      ],
+    };
+    await act(async () =>
+      root.render(createElement(FilePane, { ...props, sessions: [session] })),
+    );
+    expect(container.textContent).toContain("Looking now");
+    expect(container.textContent).not.toContain(
+      "This agent is no longer running",
+    );
+
+    await act(async () =>
+      root.render(
+        createElement(FilePane, {
+          ...props,
+          sessions: [
+            {
+              ...session,
+              blocks: [
+                ...session.blocks,
+                { id: "a2", role: "assistant" as const, text: "Done" },
+              ],
+            },
+          ],
+        }),
+      ),
+    );
+    expect(container.textContent).toContain("Done");
+  });
+});
diff --git a/src/surfaces/FilePane.tsx b/src/surfaces/FilePane.tsx
index 916c8c57..e659d666 100644
--- a/src/surfaces/FilePane.tsx
+++ b/src/surfaces/FilePane.tsx
@@ -6,6 +6,7 @@ import {
 } from "../chrome/MarkdownModeToggle";
 import { SurfaceTabs } from "../chrome/SurfaceTabs";
 import {
+  isAgentTab,
   isChangesTab,
   isCommitTab,
   isPlanTab,
@@ -24,6 +25,7 @@ import type { PlanBuildTarget, Session } from "../lib/session";
 import { Play } from "../chrome/icons";
 import { BuildTargetButton } from "../chrome/SecondOpinionButton";
 import { loadDiffViewer, subscribeDiffViewer } from "../lib/settings";
+import { AgentTabView } from "./AgentTabView";
 import { MarkdownPreview } from "./AgentMarkdown";
 import { BinaryFileView } from "./BinaryFileView";
 import { CommitDiff } from "./CommitDiff";
@@ -149,7 +151,16 @@ function FilePaneComponent({
                   : "hidden"
               }
             >
-              {isPlanTab(file) ? (
+              {isAgentTab(file) ? (
+                <AgentTabView
+                  title={file.path}
+                  session={sessions.find(
+                    (entry) => entry.id === file.agent.sessionId,
+                  )}
+                  visible={file.id === pane.activeFileId}
+                  onOpenFile={onOpenFile}
+                />
+              ) : isPlanTab(file) ? (
                 <PlanSurface
                   file={file}
                   sessions={sessions}
@@ -223,7 +234,8 @@ export const FilePane = memo(FilePaneComponent, (previous, next) => {
   }
 
   for (const file of next.pane.files) {
-    const sessionId = file.plan?.sessionId;
+    // Plans and agent tabs both read a live session object from this pane.
+    const sessionId = file.plan?.sessionId ?? file.agent?.sessionId;
     if (!sessionId) continue;
     const before = previous.sessions.find(
       (session) => session.id === sessionId,
diff --git a/src/surfaces/PaneTree.tsx b/src/surfaces/PaneTree.tsx
index b5cc73d3..5b5dde22 100644
--- a/src/surfaces/PaneTree.tsx
+++ b/src/surfaces/PaneTree.tsx
@@ -31,7 +31,7 @@ import {
   type PlanBuildTarget,
   type RuntimeMode,
   type Session,
-  type TurnIntent,
+  type ComposerTurnOptions,
 } from "../lib/session";
 import { FilePane } from "./FilePane";
 import { SessionPane } from "./SessionPane";
@@ -69,7 +69,7 @@ type Shared = {
     sessionId: string,
     text: string,
     attachments: Attachment[],
-    options?: { intent?: TurnIntent },
+    options?: ComposerTurnOptions,
   ) => void;
   onStop: (sessionId: string) => void;
   onCompactContext: (sessionId: string) => boolean;
diff --git a/src/surfaces/SessionPane.tsx b/src/surfaces/SessionPane.tsx
index 9d3e5322..bd27e4c5 100644
--- a/src/surfaces/SessionPane.tsx
+++ b/src/surfaces/SessionPane.tsx
@@ -10,6 +10,7 @@ import {
   type PointerEvent as ReactPointerEvent,
 } from "react";
 import { Composer } from "../chrome/Composer";
+import { orchestrator, sameCheckout } from "../lib/orchestration";
 import { DiscussionEmpty } from "../chrome/DiscussionEmpty";
 import { LinkedWorkItemUpdateNotice } from "../chrome/LinkedWorkItemUpdateNotice";
 import { SessionReview } from "../chrome/SessionReview";
@@ -30,7 +31,7 @@ import {
   type PlanBuildTarget,
   type RuntimeMode,
   type Session,
-  type TurnIntent,
+  type ComposerTurnOptions,
 } from "../lib/session";
 import { AgentTranscript } from "./AgentTranscript";
 import { EmptySession } from "./EmptySession";
@@ -84,7 +85,7 @@ type Props = {
     sessionId: string,
     text: string,
     attachments: Attachment[],
-    options?: { intent?: TurnIntent },
+    options?: ComposerTurnOptions,
   ) => void;
   onStop: (sessionId: string) => void;
   onCompactContext: (sessionId: string) => boolean;
@@ -191,6 +192,16 @@ export const SessionPane = memo(function SessionPane({
   onNewTerminal,
   onPaneDragStart,
 }: Props) {
+  const orchestrationRuns = useSyncExternalStore(
+    orchestrator.subscribe,
+    orchestrator.snapshot,
+    orchestrator.snapshot,
+  );
+  const managed = orchestrationRuns.some(
+    (run) =>
+      (run.status === "active" || run.status === "paused") &&
+      sameCheckout(run.cwd, sessionWorkCwd(session)),
+  );
   const title = sessionDisplayTitle(session.title, session.harness);
   const isEmpty = session.blocks.length === 0;
   const backgroundRevision = useSyncExternalStore(
@@ -248,6 +259,11 @@ export const SessionPane = memo(function SessionPane({
   useEffect(() => {
     if (!visible) setAstraWelcomeRun(null);
   }, [visible]);
+  // Restore a saved run for this lead; its agents render on the sidebar card.
+  useEffect(() => {
+    if (!session.inboxAsk)
+      void orchestrator.hydrate(session.id).catch(console.error);
+  }, [session.id, session.inboxAsk]);
   const [quoteRequest, setQuoteRequest] = useState<QuoteRequest>();
   const onJumpToBottomReady = useCallback((jump: () => void) => {
     jumpToBottomRef.current = jump;
@@ -335,7 +351,7 @@ export const SessionPane = memo(function SessionPane({
         !!session.inboxAsk ||
         (hideProjectPicker ? !showDeckProjectPicker : false)
       }
-      hideBranchPicker={!!session.inboxAsk}
+      hideBranchPicker={!!session.inboxAsk || managed}
       hideTopBar={!!session.inboxAsk}
       context={session.context}
       quoteRequest={quoteRequest}
@@ -460,120 +476,138 @@ export const SessionPane = memo(function SessionPane({
           </button>
         </div>
       ) : null}
-      <div ref={transcriptScope} className="@container relative min-h-0 flex-1">
-        {visible && focused && !session.inboxAsk ? (
-          <LinkedWorkItemUpdateNotice
-            sessionId={session.id}
-            card={session.linkedWorkItemUpdateCard}
-            onAcknowledge={() => {
-              const updatedAt = session.linkedWorkItemUpdateCard?.updatedAt;
-              if (updatedAt != null) {
-                markLinkedSessionUpdateSeen(session.id, updatedAt);
-              }
-            }}
-            onDismiss={() => onLinkedWorkItemUpdateCardDismiss?.(session.id)}
-            onOpenDiscussion={() => {
-              if (session.linkedWorkItem) {
-                onOpenLinkedWorkItem?.(session.linkedWorkItem);
-              }
-            }}
-            onAddToChat={(text) => addSelectionToChat(text, "plain")}
-            onArchiveSession={
-              onArchiveSession
-                ? () => onArchiveSession(session.id, true)
-                : undefined
-            }
-            onDeleteSession={
-              onDeleteSession ? () => onDeleteSession(session.id) : undefined
-            }
-          />
-        ) : null}
-        {isEmpty ? (
-          session.inboxAsk ? (
-            <div className="scrollbar-none h-full min-h-0 overflow-y-auto">
-              <DiscussionEmpty message="Explore this item with your agent." />
-            </div>
-          ) : (
-            <EmptySession
-              cwd={session.cwd}
-              hasChatBackground={Boolean(
-                projectBackground || globalBackgroundPath,
-              )}
-              composer={dockComposer ? undefined : composer}
-            />
-          )
-        ) : (
-          <>
-            <AgentTranscript
-              blocks={session.blocks}
-              busy={!!session.busy}
-              visible={visible}
-              cwd={workCwd}
-              harness={session.harness}
-              model={session.model}
-              pendingQuestion={!!session.pendingQuestion}
-              onApproval={approve}
-              onAddToChat={addSelectionToChat}
-              onSaveNote={notesEnabled ? saveNote : undefined}
-              onSaveSelectionNote={notesEnabled ? saveSelectionNote : undefined}
-              onOpenFile={onOpenFile}
-              onOpenDiff={onOpenDiff}
-              onOpenPlan={openPlan}
-              onBuildPlan={buildPlan}
-              onSecondOpinion={
-                !session.inboxAsk && onSecondOpinion
-                  ? (harness, turn, model) =>
-                      onSecondOpinion(session.id, harness, turn, model)
-                  : undefined
-              }
-              onHandoff={
-                !session.inboxAsk && onHandoff
-                  ? (harness, turn, model) =>
-                      onHandoff(session.id, harness, turn, model)
+      <div className="flex min-h-0 min-w-0 flex-1 flex-col">
+        <div
+          ref={transcriptScope}
+          className="@container relative min-h-0 flex-1"
+        >
+          {visible && focused && !session.inboxAsk ? (
+            <LinkedWorkItemUpdateNotice
+              sessionId={session.id}
+              card={session.linkedWorkItemUpdateCard}
+              onAcknowledge={() => {
+                const updatedAt = session.linkedWorkItemUpdateCard?.updatedAt;
+                if (updatedAt != null) {
+                  markLinkedSessionUpdateSeen(session.id, updatedAt);
+                }
+              }}
+              onDismiss={() => onLinkedWorkItemUpdateCardDismiss?.(session.id)}
+              onOpenDiscussion={() => {
+                if (session.linkedWorkItem) {
+                  onOpenLinkedWorkItem?.(session.linkedWorkItem);
+                }
+              }}
+              onAddToChat={(text) => addSelectionToChat(text, "plain")}
+              onArchiveSession={
+                onArchiveSession
+                  ? () => onArchiveSession(session.id, true)
                   : undefined
               }
-              onJumpToBottomChange={setShowJumpToBottom}
-              onJumpToBottomReady={onJumpToBottomReady}
-              onRevealReady={onRevealReady}
-              latestTurnAccessory={
-                session.inboxAsk ? undefined : (
-                  <SessionReview
-                    sessionId={session.id}
-                    cwd={workCwd}
-                    enabled={visible}
-                    busy={!!session.busy}
-                    undoLocked={reviewUndoLocked}
-                    onOpenDiff={onOpenDiff}
-                  />
-                )
+              onDeleteSession={
+                onDeleteSession ? () => onDeleteSession(session.id) : undefined
               }
             />
-            <PromptOutline
-              blocks={session.blocks}
-              scope={transcriptScope}
-              visible={visible}
-              revealBlock={revealBlock}
-            />
-            {showJumpToBottom ? (
-              <div className="pointer-events-none absolute inset-x-0 bottom-2 z-30 flex justify-center">
-                <button
-                  type="button"
-                  title="Jump to latest"
-                  aria-label="Jump to latest"
-                  data-jump-to-bottom
-                  onClick={() => jumpToBottomRef.current?.()}
-                  className="pointer-events-auto grid size-6 place-items-center rounded-md border border-content/15 bg-content/10 text-content shadow-md hover:bg-content/5 backdrop-blur-md"
-                >
-                  <ChevronDown className="size-4" strokeWidth={2} />
-                </button>
+          ) : null}
+          {isEmpty ? (
+            session.inboxAsk ? (
+              <div className="scrollbar-none h-full min-h-0 overflow-y-auto">
+                <DiscussionEmpty message="Explore this item with your agent." />
               </div>
-            ) : null}
-          </>
-        )}
+            ) : (
+              <EmptySession
+                cwd={session.cwd}
+                hasChatBackground={Boolean(
+                  projectBackground || globalBackgroundPath,
+                )}
+                composer={dockComposer ? undefined : composer}
+              />
+            )
+          ) : (
+            <>
+              <AgentTranscript
+                blocks={session.blocks}
+                busy={!!session.busy}
+                visible={visible}
+                cwd={workCwd}
+                harness={session.harness}
+                model={session.model}
+                pendingQuestion={!!session.pendingQuestion}
+                onApproval={approve}
+                onAddToChat={addSelectionToChat}
+                onSaveNote={notesEnabled ? saveNote : undefined}
+                onSaveSelectionNote={
+                  notesEnabled ? saveSelectionNote : undefined
+                }
+                onOpenFile={onOpenFile}
+                onOpenDiff={onOpenDiff}
+                onOpenPlan={openPlan}
+                onBuildPlan={buildPlan}
+                onSecondOpinion={
+                  !session.inboxAsk && onSecondOpinion
+                    ? (harness, turn, model) =>
+                        onSecondOpinion(session.id, harness, turn, model)
+                    : undefined
+                }
+                onHandoff={
+                  !session.inboxAsk && onHandoff
+                    ? (harness, turn, model) =>
+                        onHandoff(session.id, harness, turn, model)
+                    : undefined
+                }
+                onJumpToBottomChange={setShowJumpToBottom}
+                onJumpToBottomReady={onJumpToBottomReady}
+                onRevealReady={onRevealReady}
+                latestTurnAccessory={
+                  session.inboxAsk ? undefined : (
+                    <SessionReview
+                      sessionId={session.id}
+                      cwd={workCwd}
+                      enabled={visible}
+                      busy={!!session.busy}
+                      undoLocked={
+                        reviewUndoLocked ||
+                        orchestrationRuns.some(
+                          (run) =>
+                            (run.status === "active" ||
+                              run.status === "paused") &&
+                            (run.leadId === session.id ||
+                              run.tasks.some(
+                                (task) => task.sessionId === session.id,
+                              )),
+                        )
+                      }
+                      onOpenDiff={onOpenDiff}
+                    />
+                  )
+                }
+              />
+              <PromptOutline
+                blocks={session.blocks}
+                scope={transcriptScope}
+                visible={visible}
+                revealBlock={revealBlock}
+              />
+              {showJumpToBottom ? (
+                <div className="pointer-events-none absolute inset-x-0 bottom-2 z-30 flex justify-center">
+                  <button
+                    type="button"
+                    title="Jump to latest"
+                    aria-label="Jump to latest"
+                    data-jump-to-bottom
+                    onClick={() => jumpToBottomRef.current?.()}
+                    className="pointer-events-auto grid size-6 place-items-center rounded-md border border-content/15 bg-content/10 text-content shadow-md hover:bg-content/5 backdrop-blur-md"
+                  >
+                    <ChevronDown className="size-4" strokeWidth={2} />
+                  </button>
+                </div>
+              ) : null}
+            </>
+          )}
+        </div>
+        {dockComposer ? (
+          <div className="mx-auto w-full max-w-4xl shrink-0">{composer}</div>
+        ) : null}
       </div>
-      {dockComposer ? (
-        <div className="mx-auto w-full max-w-4xl shrink-0">{composer}</div>
-      ) : null}
     </div>
   );
 });
diff --git a/src/surfaces/transcriptActivity.test.ts b/src/surfaces/transcriptActivity.test.ts
index d3fe6a8b..ec7c49f0 100644
--- a/src/surfaces/transcriptActivity.test.ts
+++ b/src/surfaces/transcriptActivity.test.ts
@@ -332,6 +332,26 @@ describe("turnCopyText", () => {
 });
 
 describe("groupTurns", () => {
+  it("folds an orchestration turn the app wrote into the turn above", () => {
+    const turns = groupTurns([
+      { id: "u1", role: "user", text: "Review the changes" },
+      { id: "a1", role: "assistant", text: "Delegating." },
+      {
+        id: "u2",
+        role: "user",
+        text: "Worker results are ready.",
+        internal: true,
+      },
+      { id: "a2", role: "assistant", text: "All three look right." },
+      { id: "u3", role: "user", text: "Ship it" },
+      { id: "a3", role: "assistant", text: "Done." },
+    ]);
+    // One thread: the app's turn neither splits it nor shows up in it.
+    expect(turns.map((turn) => turn.map((block) => block.id))).toEqual([
+      ["u1", "a1", "a2"],
+      ["u3", "a3"],
+    ]);
+  });
   it("keeps a handoff divider on its own row between providers", () => {
     const turns = groupTurns([
       { id: "u1", role: "user", text: "go" },
diff --git a/src/surfaces/transcriptActivity.ts b/src/surfaces/transcriptActivity.ts
index 3b2ba00b..21367345 100644
--- a/src/surfaces/transcriptActivity.ts
+++ b/src/surfaces/transcriptActivity.ts
@@ -173,11 +173,20 @@ export function editVerb(label: string): string {
   return "Edit";
 }
 
-/** User turns, with handoff dividers sitting on their own row. */
-export function groupTurns(blocks: Block[]): Block[][] {
+/**
+ * User turns, with handoff dividers sitting on their own row. `managed` is for
+ * a worker's own transcript, where the app-written turns are the orchestrator
+ * talking to it — the whole prompt side of that conversation, and the only
+ * thing its replies are answering.
+ */
+export function groupTurns(blocks: Block[], managed = false): Block[][] {
   const turns: Block[][] = [];
   let current: Block[] = [];
   for (const block of blocks) {
+    // A turn the app wrote to keep an orchestration moving is not a user
+    // message. Dropping it here folds the reply into the turn above, so a
+    // supervised run reads as one conversation.
+    if (block.internal && !managed) continue;
     if (block.role === "handoff") {
       if (current.length > 0) turns.push(current);
       turns.push([block]);