diff --git a/CHANGELOG.md b/CHANGELOG.md
index 512b6d3..db0bbbb 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,6 +7,25 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.8.0] - 2026-08-30
+
+### Added
+- **`ctl` control plane (C2): task and observe the hierarchy.** Building on C1's
+  channel + `spawn`/`list`:
+  - `amux ctl send <target> <text>` — deliver a task to a worker as a submitted
+    prompt. **Queue-until-idle** (agsess-gated): if the target is mid-turn the
+    text waits and is delivered (text, then Enter) once it goes idle, so a send
+    never lands in the middle of a turn. `<target>` is a pane id or role label.
+  - `amux ctl status [<target>]` — a target's live `agsess` status, or (no
+    target) the caller's subtree roll-up.
+  - `amux ctl spawn --here` — tile the worker *beside* the pane that spawned it
+    (same window), so a lead and its ICs sit in one view; default `spawn` still
+    opens a new window.
+- **Subtree-scoped control (Decision 3).** `send`/`status` on a specific target
+  are scoped to the caller's own subtree; a **root/operator** pane controls
+  everything. A worker cannot steer a sibling's team — refused with a clear JSON
+  error. (Pure `in_subtree` guard, unit-tested.)
+
 ## [0.7.0] - 2026-08-30
 
 ### Added
diff --git a/Cargo.toml b/Cargo.toml
index 56aad17..bc20e60 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "amux"
-version = "0.7.0"
+version = "0.8.0"
 edition = "2021"
 rust-version = "1.70"
 description = "tmux for agents: a multi-agent terminal that hosts your own CLIs in switchable panes with agent-aware chrome. 100% nativelite - zero third-party dependencies."
diff --git a/src/ctl.rs b/src/ctl.rs
index cf5985b..384dd4a 100644
--- a/src/ctl.rs
+++ b/src/ctl.rs
@@ -9,8 +9,10 @@
 //!   *pure* guard — allowlist + depth cap — so the safety rules are unit-tested
 //!   without a pty or a running amux.
 //!
-//! C1 surface: `spawn` (open a visible worker pane) and `list` (the org chart).
-//! `send` / `status` / `kill` arrive in C2–C3.
+//! Surface: `spawn` (open a visible worker — new window or `--here` split),
+//! `list` (the org chart), `send` (queue-until-idle task delivery), and
+//! `status` (agsess-backed). `send`/`status` with a target are subtree-scoped.
+//! `kill` + identity delegation arrive in C3.
 
 use std::process::ExitCode;
 
@@ -38,13 +40,34 @@ pub struct Request {
     pub cmd: Cmd,
 }
 
-/// The C1 command set.
+/// The command set (C1: spawn/list; C2 adds send/status).
 #[derive(Debug, Clone, PartialEq)]
 pub enum Cmd {
     /// Open a new worker pane running `argv`, tagged `role`.
     Spawn(SpawnReq),
     /// Report the spawn tree.
     List,
+    /// Feed `text` to a target pane's agent as a submitted prompt (queued until
+    /// the target is idle).
+    Send(SendReq),
+    /// Report status: one target, or (no target) the caller's visible subtree.
+    Status(StatusReq),
+}
+
+/// A `send` request's payload.
+#[derive(Debug, Clone, PartialEq)]
+pub struct SendReq {
+    /// Pane id (numeric) or role label to deliver to.
+    pub target: String,
+    /// The task/prompt text to submit.
+    pub text: String,
+}
+
+/// A `status` request's payload.
+#[derive(Debug, Clone, PartialEq)]
+pub struct StatusReq {
+    /// A specific pane id/role, or `None` for the caller's subtree roll-up.
+    pub target: Option<String>,
 }
 
 /// A `spawn` request's payload.
@@ -54,7 +77,8 @@ pub struct SpawnReq {
     /// The command to host, e.g. `["claude"]`. Must be non-empty and on the
     /// agent allowlist (checked by [`evaluate_spawn`]).
     pub argv: Vec<String>,
-    /// Open in a new window (true, the C1 default) vs. split the caller (later).
+    /// Open in a new window (true, the default) vs. `--here` split beside the
+    /// caller (false).
     pub new_window: bool,
 }
 
@@ -117,6 +141,60 @@ pub fn evaluate_spawn(
     Ok(attempted)
 }
 
+/// Resolve a `send`/`status` target string to a pane's agent id. A numeric
+/// target matches by agent id; otherwise it matches by role label. `candidates`
+/// is `(agent_id, role)` for every live pane. Returns a clear error when the
+/// target is unknown or a role is ambiguous (matches more than one pane). Pure.
+pub fn resolve_target(
+    target: &str,
+    candidates: &[(usize, Option<String>)],
+) -> Result<usize, String> {
+    if let Ok(id) = target.parse::<usize>() {
+        if candidates.iter().any(|(cid, _)| *cid == id) {
+            return Ok(id);
+        }
+        return Err(format!("no pane with id {id}"));
+    }
+    let hits: Vec<usize> = candidates
+        .iter()
+        .filter(|(_, role)| role.as_deref() == Some(target))
+        .map(|(cid, _)| *cid)
+        .collect();
+    match hits.as_slice() {
+        [] => Err(format!("no pane with id or role {target:?}")),
+        [one] => Ok(*one),
+        many => Err(format!(
+            "role {target:?} is ambiguous ({} panes: {}); use a pane id",
+            many.len(),
+            many.iter()
+                .map(usize::to_string)
+                .collect::<Vec<_>>()
+                .join(", ")
+        )),
+    }
+}
+
+/// Is `target` inside the subtree rooted at `root` (i.e. `root` itself or a
+/// descendant of it)? `parents` maps each `agent_id` to its parent. This is the
+/// **subtree-scoping guard** (Decision 3): a non-privileged caller may only
+/// `send`/`status` panes in its own subtree. Pure; cycle-guarded.
+pub fn in_subtree(target: usize, root: usize, parents: &[(usize, Option<usize>)]) -> bool {
+    if target == root {
+        return true;
+    }
+    let parent_of = |id: usize| parents.iter().find(|(i, _)| *i == id).and_then(|(_, p)| *p);
+    let mut cur = target;
+    // The tree is shallow (depth-capped) but guard against a malformed cycle.
+    for _ in 0..4096 {
+        match parent_of(cur) {
+            Some(p) if p == root => return true,
+            Some(p) => cur = p,
+            None => return false,
+        }
+    }
+    false
+}
+
 /// Environment knob (comma-separated) that extends the ctl agent allowlist
 /// beyond [`bind::AGENT_STEMS`]. Opt-in on top of `--allow-ctl` and set by the
 /// human who launches amux, so it never weakens the confused-agent guard for a
@@ -213,6 +291,23 @@ pub fn parse_request(line: &str) -> Result<Request, String> {
             })
         }
         Some("list") => Cmd::List,
+        Some("send") => {
+            let target = v
+                .get("target")
+                .and_then(Value::as_str)
+                .ok_or_else(|| "send needs a target".to_string())?
+                .to_string();
+            let text = v
+                .get("text")
+                .and_then(Value::as_str)
+                .ok_or_else(|| "send needs text".to_string())?
+                .to_string();
+            Cmd::Send(SendReq { target, text })
+        }
+        Some("status") => {
+            let target = v.get("target").and_then(Value::as_str).map(str::to_string);
+            Cmd::Status(StatusReq { target })
+        }
         Some(other) => return Err(format!("unknown command {other:?}")),
         None => return Err("request has no \"cmd\"".to_string()),
     };
@@ -249,6 +344,28 @@ pub fn reply_spawned(pane: usize, role: Option<&str>, session: Option<&str>) ->
     .to_string()
 }
 
+/// `{"ok":true,"target":<id>,"queued":<bool>}` — a `send` was accepted. `queued`
+/// is true when the target was busy (delivery waits for it to go idle), false
+/// when it will go out immediately. Delivery itself is asynchronous.
+pub fn reply_sent(target: usize, queued: bool) -> String {
+    obj(vec![
+        ("ok", Value::Bool(true)),
+        ("target", i(target)),
+        ("queued", Value::Bool(queued)),
+    ])
+    .to_string()
+}
+
+/// `{"ok":true,"pane":<id>,"status":"<label>"}` — a single target's status.
+pub fn reply_status_one(pane: usize, status: Option<&str>) -> String {
+    obj(vec![
+        ("ok", Value::Bool(true)),
+        ("pane", i(pane)),
+        ("status", status.map(s).unwrap_or(Value::Null)),
+    ])
+    .to_string()
+}
+
 /// One node in the org chart, as the run loop knows it.
 pub struct TreeNode<'a> {
     pub id: usize,
@@ -378,8 +495,27 @@ pub fn build_request(args: &[String], caller: Option<usize>) -> Result<String, S
         Some("list") => {
             pairs.push(("cmd", s("list")));
         }
+        Some("send") => {
+            pairs.push(("cmd", s("send")));
+            let target = args
+                .get(1)
+                .filter(|t| !t.starts_with('-'))
+                .ok_or_else(|| "send needs a target (pane id or role)".to_string())?;
+            let text = args[2..].join(" ");
+            if text.trim().is_empty() {
+                return Err("send needs text after the target".to_string());
+            }
+            pairs.push(("target", Value::String(target.clone())));
+            pairs.push(("text", Value::String(text)));
+        }
+        Some("status") => {
+            pairs.push(("cmd", s("status")));
+            if let Some(target) = args.get(1).filter(|t| !t.starts_with('-')) {
+                pairs.push(("target", Value::String(target.clone())));
+            }
+        }
         Some(other) => return Err(format!("unknown subcommand {other:?}")),
-        None => return Err("needs a subcommand: spawn | list".to_string()),
+        None => return Err("needs a subcommand: spawn | list | send | status".to_string()),
     }
     Ok(obj(pairs).to_string())
 }
@@ -474,6 +610,83 @@ mod tests {
         }
     }
 
+    #[test]
+    fn build_and_parse_send_request() {
+        let line = build_request(&v(&["send", "dev_1", "implement", "X", "TDD"]), Some(0)).unwrap();
+        let req = parse_request(&line).unwrap();
+        assert_eq!(req.caller, Some(0));
+        match req.cmd {
+            Cmd::Send(sr) => {
+                assert_eq!(sr.target, "dev_1");
+                assert_eq!(sr.text, "implement X TDD");
+            }
+            _ => panic!("expected send"),
+        }
+    }
+
+    #[test]
+    fn send_without_text_is_an_error() {
+        let err = build_request(&v(&["send", "dev_1"]), None).unwrap_err();
+        assert!(err.contains("text"), "{err}");
+    }
+
+    #[test]
+    fn build_and_parse_status_request_with_and_without_target() {
+        let one = parse_request(&build_request(&v(&["status", "3"]), None).unwrap()).unwrap();
+        assert_eq!(
+            one.cmd,
+            Cmd::Status(StatusReq {
+                target: Some("3".into())
+            })
+        );
+        let all = parse_request(&build_request(&v(&["status"]), None).unwrap()).unwrap();
+        assert_eq!(all.cmd, Cmd::Status(StatusReq { target: None }));
+    }
+
+    #[test]
+    fn resolve_target_by_id_and_role() {
+        let panes = [
+            (0usize, Some("ceo".to_string())),
+            (1, Some("dev_1".to_string())),
+            (2, None),
+        ];
+        assert_eq!(resolve_target("1", &panes), Ok(1));
+        assert_eq!(resolve_target("dev_1", &panes), Ok(1));
+        assert!(resolve_target("9", &panes).unwrap_err().contains("no pane"));
+        assert!(resolve_target("ghost", &panes)
+            .unwrap_err()
+            .contains("no pane"));
+    }
+
+    #[test]
+    fn resolve_target_flags_ambiguous_roles() {
+        let panes = [
+            (1usize, Some("dev".to_string())),
+            (2, Some("dev".to_string())),
+        ];
+        assert!(resolve_target("dev", &panes)
+            .unwrap_err()
+            .contains("ambiguous"));
+    }
+
+    #[test]
+    fn in_subtree_walks_the_parent_chain() {
+        // 0 (root) → 1 (lead) → 2, 3 (ICs); 4 is a sibling lead's IC.
+        let parents = [
+            (0usize, None),
+            (1, Some(0)),
+            (2, Some(1)),
+            (3, Some(1)),
+            (4, Some(5)),
+            (5, Some(0)),
+        ];
+        assert!(in_subtree(2, 1, &parents)); // IC is in its lead's subtree
+        assert!(in_subtree(1, 1, &parents)); // a pane is in its own subtree
+        assert!(!in_subtree(4, 1, &parents)); // a cousin is not
+        assert!(in_subtree(4, 0, &parents)); // everything is under the root
+        assert!(!in_subtree(1, 2, &parents)); // a parent is not under its child
+    }
+
     #[test]
     fn build_list_request() {
         let line = build_request(&v(&["list"]), Some(3)).unwrap();
diff --git a/src/layout.rs b/src/layout.rs
index 58d43c7..64daee1 100644
--- a/src/layout.rs
+++ b/src/layout.rs
@@ -171,6 +171,19 @@ impl Tree {
         self.focus = new_id;
     }
 
+    /// Split a *specific* pane `target` in `dir` (not necessarily the focused
+    /// one), giving the new half pane id `new_id`, and move focus to the new
+    /// pane. Returns `false` (a no-op) if `target` is not in the tree. This is
+    /// what lets `ctl spawn --here` tile a worker beside the pane that requested
+    /// it, even when that pane is not the window's current focus.
+    pub fn split_pane(&mut self, target: usize, dir: Dir, new_id: usize) -> bool {
+        let ok = Self::split_at(&mut self.root, target, dir, new_id);
+        if ok {
+            self.focus = new_id;
+        }
+        ok
+    }
+
     fn split_at(node: &mut Node, target: usize, dir: Dir, new_id: usize) -> bool {
         match node {
             Node::Leaf(id) if *id == target => {
@@ -468,6 +481,23 @@ mod tests {
         assert_eq!(back, top_left, "up+left should return to the top-left pane");
     }
 
+    #[test]
+    fn split_pane_targets_a_specific_pane_not_just_focus() {
+        // Build [0 | 1] with focus on 1, then split pane 0 (the *unfocused* one).
+        let mut t = Tree::new(0);
+        t.split(Dir::Vertical, 1);
+        assert_eq!(t.focus(), 1);
+        assert!(t.split_pane(0, Dir::Vertical, 2));
+        // 0 became a split into {0, 2}; the tree now holds 0, 1, 2 and focus
+        // moved to the new pane.
+        let mut ids = t.ids();
+        ids.sort();
+        assert_eq!(ids, vec![0, 1, 2]);
+        assert_eq!(t.focus(), 2);
+        // Splitting a pane that isn't there is a no-op.
+        assert!(!t.split_pane(99, Dir::Vertical, 3));
+    }
+
     #[test]
     fn move_focus_is_a_noop_off_the_edge() {
         let mut t = Tree::new(0);
diff --git a/src/main.rs b/src/main.rs
index be6067c..46978c2 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -46,6 +46,76 @@ fn next_agent_id() -> usize {
     NEXT_AGENT.fetch_add(1, Ordering::Relaxed)
 }
 
+/// A `ctl send` awaiting delivery. The design queues a task until the target is
+/// **idle** (agsess-gated) rather than injecting into a live turn (Decision 4).
+/// Once the target is ready we write the text, then — after a short beat so the
+/// agent's TUI registers the line before the submit — write the Enter. The beat
+/// mirrors the C0 spike, which split the text and `\r` with a delay.
+struct PendingSend {
+    /// Target pane's global agent id (already resolved + scope-checked).
+    target: usize,
+    text: String,
+    /// When the send was accepted — a fallback so a target that never yields a
+    /// derivable status (a shell, a not-yet-bound agent) still gets it.
+    queued_at: Instant,
+    /// `Some(t)` once the text has been written; `t` gates the follow-up Enter.
+    text_written_at: Option<Instant>,
+}
+
+/// How long after writing the task text we send the Enter that submits it.
+const SEND_ENTER_DELAY: Duration = Duration::from_millis(400);
+/// If a target never yields a derivable agsess status (non-agent / unbound),
+/// deliver anyway once the send has waited this long, so a queue never wedges.
+const SEND_UNBOUND_FALLBACK: Duration = Duration::from_secs(2);
+
+/// Find a hosted pane by its global agent id (immutable / mutable).
+fn pane_by_agent(windows: &[Window], id: usize) -> Option<&Pane> {
+    windows
+        .iter()
+        .flat_map(|w| w.panes.iter())
+        .find(|p| p.agent_id == id)
+}
+fn pane_by_agent_mut(windows: &mut [Window], id: usize) -> Option<&mut Pane> {
+    windows
+        .iter_mut()
+        .flat_map(|w| w.panes.iter_mut())
+        .find(|p| p.agent_id == id)
+}
+
+/// `(agent_id, role)` for every live pane — the candidate set for target
+/// resolution.
+fn ctl_candidates(windows: &[Window]) -> Vec<(usize, Option<String>)> {
+    windows
+        .iter()
+        .flat_map(|w| w.panes.iter())
+        .map(|p| (p.agent_id, p.role.clone()))
+        .collect()
+}
+
+/// `(agent_id, parent)` for every live pane — the spawn-tree edges the subtree
+/// guard walks.
+fn ctl_parents(windows: &[Window]) -> Vec<(usize, Option<usize>)> {
+    windows
+        .iter()
+        .flat_map(|w| w.panes.iter())
+        .map(|p| (p.agent_id, p.parent))
+        .collect()
+}
+
+/// The **human** controls everything (Decision 3). A caller is human-privileged
+/// when it has no attributed pane, or when its pane is a *root* (one amux opened,
+/// `parent == None`, depth 0) — i.e. where the operator sits. A spawned worker
+/// (depth > 0) is scoped to its own subtree.
+fn caller_privileged(windows: &[Window], caller: Option<usize>) -> bool {
+    match caller {
+        None => true,
+        Some(id) => match pane_by_agent(windows, id) {
+            Some(p) => p.parent.is_none(),
+            None => true, // unknown caller (e.g. run from outside a pane) = operator
+        },
+    }
+}
+
 /// One hosted terminal: a pty, its emulator (for tiled compositing), its
 /// passthrough filter (for the passthrough / zoom path), and bar metadata. Each
 /// pane has a stable `id` the window's split tree refers to.
@@ -138,7 +208,7 @@ fn main() -> ExitCode {
     if rest.first().map(String::as_str) == Some("--help") {
         eprintln!(
             "usage: amux [--identity <name>] [--allow-ctl [--max-depth <N>]] [-n <N> | --grid <R>x<C>] [command [args...]]\n\
-             \x20      amux ctl spawn [--role R] [-- <cmd...>] | amux ctl list   (inside a --allow-ctl session)\n\
+             \x20      amux ctl spawn [--role R] [--here] -- <cmd...> | list | send <target> <text> | status [target]\n\
              \x20      (Ctrl+A ? in the bar shows keys)"
         );
         return ExitCode::SUCCESS;
@@ -227,6 +297,8 @@ fn run(
     // environment. A bind failure is non-fatal: amux still runs, just without
     // ctl, and says so in the bar (never silently unavailable).
     let mut ctl_listener: Option<amux::ipc::Listener> = None;
+    // Queue-until-idle deliveries for `ctl send` (flushed each tick).
+    let mut pending_sends: Vec<PendingSend> = Vec::new();
     // Operator-approved extra allowlist stems (AMUX_CTL_ALLOW); empty ⇒ the
     // built-in agents-only guard. Read once at startup.
     let ctl_extra_allow = if allow_ctl {
@@ -443,6 +515,7 @@ fn run(
                             cols,
                             max_depth,
                             &ctl_extra_allow,
+                            &mut pending_sends,
                             &world,
                         );
                         let _ = listener.respond(&reply);
@@ -455,6 +528,11 @@ fn run(
             }
         }
 
+        // 1c. flush any queued `ctl send`s whose target is now idle (Decision 4).
+        if flush_sends(&mut pending_sends, &mut windows, &world) {
+            force_repaint = true;
+        }
+
         // 2. drain every pane in the active window (all panes are live in
         //    tiled mode); feed the emulator, and in passthrough also write the
         //    focused pane's cleaned bytes straight through.
@@ -1111,9 +1189,13 @@ fn status_label(s: agsess::Status) -> &'static str {
 }
 
 /// Apply one ctl request against the live window set and return the JSON reply
-/// line. This is the server side of the control channel: `list` serializes the
-/// spawn tree (agsess statuses folded in), `spawn` creates a visible worker pane
-/// after the pure [`amux::ctl::evaluate_spawn`] guard (allowlist + depth) passes.
+/// line. The server side of the control channel: `list`/`status` serialize the
+/// spawn tree (agsess statuses folded in), `spawn` creates a visible worker
+/// (new window or `--here` split) after the pure [`amux::ctl::evaluate_spawn`]
+/// guard, and `send` enqueues a queue-until-idle delivery. `send`/`status` with
+/// a target are **subtree-scoped**: a non-root (non-human) caller may only reach
+/// its own subtree.
+#[allow(clippy::too_many_arguments)]
 fn apply_ctl(
     line: &str,
     windows: &mut Vec<Window>,
@@ -1121,6 +1203,7 @@ fn apply_ctl(
     cols: u16,
     max_depth: usize,
     extra_allow: &[String],
+    pending: &mut Vec<PendingSend>,
     world: &agsess::World,
 ) -> String {
     use amux::ctl::{self, Cmd};
@@ -1129,66 +1212,260 @@ fn apply_ctl(
         Ok(r) => r,
         Err(e) => return ctl::reply_err(&e),
     };
+    let privileged = caller_privileged(windows, req.caller);
 
     match req.cmd {
-        Cmd::List => {
-            let mut panes: Vec<&Pane> = windows.iter().flat_map(|w| w.panes.iter()).collect();
-            panes.sort_by_key(|p| p.agent_id);
-            let nodes: Vec<ctl::TreeNode> = panes
-                .iter()
-                .map(|p| ctl::TreeNode {
-                    id: p.agent_id,
-                    parent: p.parent,
-                    role: p.role.as_deref(),
-                    title: &p.title,
-                    depth: p.depth,
-                    status: amux::bind::status_for(p.session_id.as_deref(), &world.sessions)
-                        .map(status_label),
-                })
-                .collect();
-            ctl::reply_list(&nodes)
+        Cmd::List => reply_tree(windows, world, None),
+        Cmd::Status(sr) => match sr.target {
+            None => {
+                // No target: the caller's subtree (whole tree for the operator).
+                let root = if privileged { None } else { req.caller };
+                reply_tree(windows, world, root)
+            }
+            Some(t) => {
+                let candidates = ctl_candidates(windows);
+                let id = match ctl::resolve_target(&t, &candidates) {
+                    Ok(id) => id,
+                    Err(e) => return ctl::reply_err(&e),
+                };
+                if let Some(deny) = scope_denied(windows, req.caller, privileged, id) {
+                    return deny;
+                }
+                let status = pane_by_agent(windows, id).and_then(|p| {
+                    amux::bind::status_for(p.session_id.as_deref(), &world.sessions)
+                        .map(status_label)
+                });
+                ctl::reply_status_one(id, status)
+            }
+        },
+        Cmd::Send(sr) => {
+            let candidates = ctl_candidates(windows);
+            let id = match ctl::resolve_target(&sr.target, &candidates) {
+                Ok(id) => id,
+                Err(e) => return ctl::reply_err(&e),
+            };
+            if let Some(deny) = scope_denied(windows, req.caller, privileged, id) {
+                return deny;
+            }
+            // Queued iff the target is mid-turn now; either way delivery is async
+            // and happens when the target is idle.
+            let busy = matches!(
+                pane_by_agent(windows, id)
+                    .and_then(|p| amux::bind::status_for(p.session_id.as_deref(), &world.sessions)),
+                Some(agsess::Status::Working) | Some(agsess::Status::WaitingApproval)
+            );
+            pending.push(PendingSend {
+                target: id,
+                text: sr.text,
+                queued_at: Instant::now(),
+                text_written_at: None,
+            });
+            ctl::reply_sent(id, busy)
         }
         Cmd::Spawn(sp) => {
-            if !sp.new_window {
-                return ctl::reply_err(
-                    "`--here` (split the caller) lands in C2; C1 opens a new window — rerun without --here",
-                );
-            }
-            // The caller's depth (0 if the caller is unknown — e.g. a human pane
-            // amux did not spawn): the worker will sit one below it.
             let caller_depth = req
                 .caller
-                .and_then(|cid| {
-                    windows
-                        .iter()
-                        .flat_map(|w| w.panes.iter())
-                        .find(|p| p.agent_id == cid)
-                })
+                .and_then(|cid| pane_by_agent(windows, cid))
                 .map(|p| p.depth)
                 .unwrap_or(0);
-            match ctl::evaluate_spawn(&sp.argv, caller_depth, max_depth, extra_allow) {
-                Err(denied) => ctl::reply_err(&denied.message()),
-                Ok(new_depth) => {
-                    let mut flash = None;
-                    match spawn_window(&sp.argv, rows, cols, windows.len(), None, &mut flash) {
-                        Ok(mut w) => {
-                            // A new window from ctl spawn is a single pane; stamp
-                            // its spawn-tree fields before it joins the set.
-                            let pane = &mut w.panes[0];
-                            pane.role = sp.role.clone();
-                            pane.parent = req.caller;
-                            pane.depth = new_depth;
-                            let agent_id = pane.agent_id;
-                            let session = pane.session_id.clone();
-                            windows.push(w);
-                            ctl::reply_spawned(agent_id, sp.role.as_deref(), session.as_deref())
+            let new_depth =
+                match ctl::evaluate_spawn(&sp.argv, caller_depth, max_depth, extra_allow) {
+                    Ok(d) => d,
+                    Err(denied) => return ctl::reply_err(&denied.message()),
+                };
+            if sp.new_window {
+                spawn_worker_window(windows, &sp, req.caller, new_depth, rows, cols)
+            } else {
+                spawn_worker_here(windows, &sp, req.caller, new_depth, rows, cols)
+            }
+        }
+    }
+}
+
+/// Serialize the spawn tree as a `list`/`status` reply. `root == Some(id)` limits
+/// it to that pane's subtree (subtree-scoped status); `None` is the whole tree.
+fn reply_tree(windows: &[Window], world: &agsess::World, root: Option<usize>) -> String {
+    let parents = ctl_parents(windows);
+    let mut panes: Vec<&Pane> = windows
+        .iter()
+        .flat_map(|w| w.panes.iter())
+        .filter(|p| match root {
+            None => true,
+            Some(r) => amux::ctl::in_subtree(p.agent_id, r, &parents),
+        })
+        .collect();
+    panes.sort_by_key(|p| p.agent_id);
+    let nodes: Vec<amux::ctl::TreeNode> = panes
+        .iter()
+        .map(|p| amux::ctl::TreeNode {
+            id: p.agent_id,
+            parent: p.parent,
+            role: p.role.as_deref(),
+            title: &p.title,
+            depth: p.depth,
+            status: amux::bind::status_for(p.session_id.as_deref(), &world.sessions)
+                .map(status_label),
+        })
+        .collect();
+    amux::ctl::reply_list(&nodes)
+}
+
+/// Subtree-scope guard: `None` if the caller may act on `target`, else a ready
+/// JSON refusal. The operator (privileged) may act on anything.
+fn scope_denied(
+    windows: &[Window],
+    caller: Option<usize>,
+    privileged: bool,
+    target: usize,
+) -> Option<String> {
+    if privileged {
+        return None;
+    }
+    let root = caller?; // non-privileged implies a known caller pane
+    if amux::ctl::in_subtree(target, root, &ctl_parents(windows)) {
+        None
+    } else {
+        Some(amux::ctl::reply_err(&format!(
+            "pane {target} is outside your subtree; a worker may only steer what it spawned"
+        )))
+    }
+}
+
+/// `ctl spawn` (default): a visible worker in a brand-new window.
+fn spawn_worker_window(
+    windows: &mut Vec<Window>,
+    sp: &amux::ctl::SpawnReq,
+    caller: Option<usize>,
+    new_depth: usize,
+    rows: u16,
+    cols: u16,
+) -> String {
+    let mut flash = None;
+    match spawn_window(&sp.argv, rows, cols, windows.len(), None, &mut flash) {
+        Ok(mut w) => {
+            let pane = &mut w.panes[0];
+            pane.role = sp.role.clone();
+            pane.parent = caller;
+            pane.depth = new_depth;
+            let agent_id = pane.agent_id;
+            let session = pane.session_id.clone();
+            windows.push(w);
+            amux::ctl::reply_spawned(agent_id, sp.role.as_deref(), session.as_deref())
+        }
+        Err(e) => amux::ctl::reply_err(&format!("spawn failed: {e}")),
+    }
+}
+
+/// `ctl spawn --here`: tile the worker *beside* the caller, in the caller's own
+/// window, so a lead and its ICs sit in one view. Falls back to an error if the
+/// caller's pane can't be located (nothing to sit beside).
+fn spawn_worker_here(
+    windows: &mut [Window],
+    sp: &amux::ctl::SpawnReq,
+    caller: Option<usize>,
+    new_depth: usize,
+    rows: u16,
+    cols: u16,
+) -> String {
+    let Some(caller_id) = caller else {
+        return amux::ctl::reply_err(
+            "`--here` needs a caller pane; run it from inside an amux pane",
+        );
+    };
+    // Locate the window holding the caller and that caller's per-window pane id.
+    let Some((wi, caller_pane_id)) = windows.iter().enumerate().find_map(|(i, w)| {
+        w.panes
+            .iter()
+            .find(|p| p.agent_id == caller_id)
+            .map(|p| (i, p.id))
+    }) else {
+        return amux::ctl::reply_err("`--here`: caller pane not found (rerun without --here)");
+    };
+
+    let w = &mut windows[wi];
+    let new_id = w.next_id;
+    // Rough half-cell inner size; the caller resizes the window right after.
+    let (pr, pc) = (
+        (rows.saturating_sub(1).max(1) / 2).saturating_sub(2),
+        (cols / 2).saturating_sub(2),
+    );
+    let mut flash = None;
+    match spawn_pane(&sp.argv, pr.max(1), pc.max(1), new_id, None, &mut flash) {
+        Ok(mut pane) => {
+            pane.role = sp.role.clone();
+            pane.parent = caller;
+            pane.depth = new_depth;
+            let agent_id = pane.agent_id;
+            let session = pane.session_id.clone();
+            w.panes.push(pane);
+            w.next_id += 1;
+            // Split beside the caller specifically (side-by-side), not just the
+            // window's current focus.
+            w.tree
+                .split_pane(caller_pane_id, layout::Dir::Vertical, new_id);
+            w.zoomed = false;
+            amux::ctl::reply_spawned(agent_id, sp.role.as_deref(), session.as_deref())
+        }
+        Err(e) => amux::ctl::reply_err(&format!("spawn failed: {e}")),
+    }
+}
+
+/// Flush queued `ctl send`s (Decision 4: queue until the target is idle). For
+/// each pending send: once the target reports a ready status (or the unbound
+/// fallback elapses), write the text; a beat later write the Enter and drop it.
+/// A vanished target is dropped. Returns whether anything was written (so the
+/// caller can request a repaint).
+fn flush_sends(
+    pending: &mut Vec<PendingSend>,
+    windows: &mut [Window],
+    world: &agsess::World,
+) -> bool {
+    if pending.is_empty() {
+        return false;
+    }
+    let now = Instant::now();
+    let mut wrote = false;
+    pending.retain_mut(|ps| {
+        match ps.text_written_at {
+            None => {
+                // Decide readiness from the target's live status.
+                let ready = match pane_by_agent(windows, ps.target) {
+                    None => return false, // target gone — drop the send
+                    Some(p) => {
+                        match amux::bind::status_for(p.session_id.as_deref(), &world.sessions) {
+                            Some(agsess::Status::WaitingPrompt) | Some(agsess::Status::Idle) => {
+                                true
+                            }
+                            Some(_) => false, // Working / WaitingApproval — keep waiting
+                            None => now.duration_since(ps.queued_at) >= SEND_UNBOUND_FALLBACK,
                         }
-                        Err(e) => ctl::reply_err(&format!("spawn failed: {e}")),
+                    }
+                };
+                if ready {
+                    if let Some(p) = pane_by_agent_mut(windows, ps.target) {
+                        let _ = p.pty.write(ps.text.as_bytes());
+                        ps.text_written_at = Some(now);
+                        wrote = true;
+                    } else {
+                        return false;
                     }
                 }
+                true
+            }
+            Some(t) => {
+                if now.duration_since(t) >= SEND_ENTER_DELAY {
+                    if let Some(p) = pane_by_agent_mut(windows, ps.target) {
+                        let _ = p.pty.write(b"\r");
+                        wrote = true;
+                    }
+                    false // delivered — drop
+                } else {
+                    true
+                }
             }
         }
-    }
+    });
+    wrote
 }
 
 fn spawn_window(
diff --git a/tests/amux.rs b/tests/amux.rs
index 4226aab..6aeb532 100644
--- a/tests/amux.rs
+++ b/tests/amux.rs
@@ -952,3 +952,66 @@ fn ctl_spawn_off_the_allowlist_is_refused() {
     p.write(b"\x01q").unwrap();
     let _ = wait_exit(&mut p, 15);
 }
+
+/// `amux ctl status <id>` returns a target's status as JSON. Pane 0 is always
+/// the initial pane (agent ids are process-global from 0), so this is stable.
+#[test]
+fn ctl_status_reports_a_pane() {
+    let (mut p, _shell, _flag) = spawn_amux_ctl_shell();
+    let amux = env!("CARGO_BIN_EXE_amux");
+    p.write(format!("\"{amux}\" ctl status 0\r\n").as_bytes())
+        .unwrap();
+    let out = read_until(&mut p, b"\"pane\":0", Duration::from_secs(20));
+    assert!(
+        contains(&out, b"\"ok\":true") && contains(&out, b"\"pane\":0"),
+        "no status reply: {:?}",
+        String::from_utf8_lossy(&out)
+    );
+    p.write(b"\x01q").unwrap();
+    let _ = wait_exit(&mut p, 15);
+}
+
+/// `amux ctl send <role> <text>` delivers the text to the worker as input. We
+/// spawn the worker in a *new* window, task it from the caller window, then
+/// switch to the worker window to observe: the marker appears there only if the
+/// send actually reached the worker's pty (the caller's command echo lives in a
+/// different window, so it can't produce a false positive).
+#[test]
+fn ctl_send_delivers_a_task_to_a_worker() {
+    let (mut p, shell, _flag) = spawn_amux_ctl_shell();
+    let amux = env!("CARGO_BIN_EXE_amux");
+    let two: &[u8] = if cfg!(windows) { b"2:cmd" } else { b"2:sh" };
+    p.write(format!("\"{amux}\" ctl spawn --role dev_1 -- {shell}\r\n").as_bytes())
+        .unwrap();
+    read_until(&mut p, two, Duration::from_secs(20)); // worker window opened
+    p.write(format!("\"{amux}\" ctl send dev_1 echo WORKERMARK7\r\n").as_bytes())
+        .unwrap();
+    p.write(b"\x012").unwrap(); // Ctrl+A 2 -> watch the worker window
+    let out = read_until(&mut p, b"WORKERMARK7", Duration::from_secs(20));
+    assert!(
+        contains(&out, b"WORKERMARK7"),
+        "worker never received the send: {:?}",
+        String::from_utf8_lossy(&out)
+    );
+    p.write(b"\x01q").unwrap();
+    let _ = wait_exit(&mut p, 15);
+}
+
+/// `amux ctl spawn --here` succeeds over the channel (tiles the worker beside its
+/// caller): the reply carries the worker's role, proving the split-placement path
+/// ran end to end.
+#[test]
+fn ctl_spawn_here_succeeds() {
+    let (mut p, shell, _flag) = spawn_amux_ctl_shell();
+    let amux = env!("CARGO_BIN_EXE_amux");
+    p.write(format!("\"{amux}\" ctl spawn --here --role dev_1 -- {shell}\r\n").as_bytes())
+        .unwrap();
+    let out = read_until(&mut p, b"\"role\":\"dev_1\"", Duration::from_secs(20));
+    assert!(
+        contains(&out, b"\"ok\":true") && contains(&out, b"\"role\":\"dev_1\""),
+        "no --here spawn reply: {:?}",
+        String::from_utf8_lossy(&out)
+    );
+    p.write(b"\x01q").unwrap();
+    let _ = wait_exit(&mut p, 15);
+}