feat(maestro): auto-approve ACP permissions via preset config

Structured sessions ignored the --dangerously-skip-permissions flags in
preset commands because the daemon discards CLI flags when spawning the
ACP adapter binary. This adds an `auto_approve` bool to SpawnPreset and
CreateSessionRequest so the operator can declare it in config.toml:

  { id = "claude", command = "claude", auto_approve = true }

When set, the daemon's permission pump immediately responds AllowAlways
to every ACP permission request without surfacing it to clients.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

crates/maestro-cli/src/cli.rs

@@ -92,14 +92,6 @@ pub struct SpawnArgs {
     /// there.
     #[arg(long)]
     pub existing_branch: bool,
-    /// Run a Claude Code or Codex session in a plain terminal instead of the
-    /// structured (ACP) view it otherwise gets by default.
-    #[arg(long, conflicts_with = "structured")]
-    pub terminal: bool,
-    /// Ask for the structured (ACP) view explicitly. Only Claude Code and
-    /// Codex commands have an adapter; the daemon refuses anything else.
-    #[arg(long)]
-    pub structured: bool,
     /// After spawning, attach immediately.
     #[arg(long, short = 'a')]
     pub attach: bool,

crates/maestro-cli/src/sessions.rs

@@ -3,7 +3,7 @@
 use std::collections::HashMap;
 use std::io::Write;
 
-use maestro_protocol::display::{abbreviate_dir, supports_structured_view};
+use maestro_protocol::display::abbreviate_dir;
 use maestro_protocol::{
     ActivityState, ClientError, CreateSessionRequest, DaemonClient, DaemonInfo, SendInputRequest,
     Session, SessionStatus, SessionView, WorktreeSpec,
@@ -51,7 +51,7 @@ pub async fn run_spawn(client: &DaemonClient, args: SpawnArgs) -> Result<Session
     };
 
     let body = CreateSessionRequest {
-        view: spawn_view(&args),
+        view: Default::default(),
         cwd: args.cwd.clone(),
         command: args.command.clone(),
         env,
@@ -62,22 +62,6 @@ pub async fn run_spawn(client: &DaemonClient, args: SpawnArgs) -> Result<Session
     client.create_session(&body).await
 }
 
-/// The view a `maestro spawn` asks for: structured whenever the command
-/// resolves to an agent with an ACP adapter, since that is the richer session
-/// and the one both other clients now default to. `--terminal` opts out;
-/// `--structured` forces the request through even for a command this side
-/// does not recognise, leaving the refusal to the daemon.
-fn spawn_view(args: &SpawnArgs) -> SessionView {
-    if args.terminal {
-        return SessionView::Terminal;
-    }
-    if args.structured || supports_structured_view(&args.command) {
-        SessionView::Structured
-    } else {
-        SessionView::Terminal
-    }
-}
-
 /// `maestro kill`. A forced kill (#81) retains the guarded worktree instead
 /// of removing it; the outcome names what was kept so dispatch can say where
 /// the work went.
@@ -256,62 +240,6 @@ mod tests {
 
     use super::DaemonInfo;
 
-    use clap::Parser;
-
-    use crate::cli::{Cli, Command};
-
-    fn spawn_args(extra: &[&str]) -> crate::cli::SpawnArgs {
-        let mut argv = vec!["maestro", "spawn", "--cwd", "/tmp", "--command"];
-        argv.extend_from_slice(extra);
-        let cli = Cli::try_parse_from(argv).expect("parses");
-        let Command::Spawn(args) = cli.command else {
-            panic!("expected spawn")
-        };
-        args
-    }
-
-    /// The CLI follows the two interactive clients: a command with an ACP
-    /// adapter spawns structured unless `--terminal` says otherwise, and
-    /// `--structured` still forces the request for a command this side does
-    /// not recognise.
-    #[test]
-    fn spawn_defaults_to_structured_for_supported_agents() {
-        use super::spawn_view;
-        assert_eq!(
-            spawn_view(&spawn_args(&["claude"])),
-            SessionView::Structured
-        );
-        assert_eq!(
-            spawn_view(&spawn_args(&["npx codex exec"])),
-            SessionView::Structured
-        );
-        assert_eq!(spawn_view(&spawn_args(&["bash"])), SessionView::Terminal);
-        assert_eq!(
-            spawn_view(&spawn_args(&["claude", "--terminal"])),
-            SessionView::Terminal
-        );
-        assert_eq!(
-            spawn_view(&spawn_args(&["opencode", "--structured"])),
-            SessionView::Structured
-        );
-    }
-
-    #[test]
-    fn spawn_refuses_both_view_flags_at_once() {
-        let err = Cli::try_parse_from([
-            "maestro",
-            "spawn",
-            "--cwd",
-            "/tmp",
-            "--command",
-            "claude",
-            "--structured",
-            "--terminal",
-        ])
-        .unwrap_err();
-        assert!(err.to_string().contains("--terminal"), "{err}");
-    }
-
     fn session(cwd: &str, command: &str, id: u128) -> Session {
         Session {
             view: Default::default(),

crates/maestro-daemon/src/local_api.rs

@@ -12,8 +12,7 @@
 
 use std::sync::Arc;
 
-use axum::body::Bytes;
+use axum::extract::{Path, Query, State};
-use axum::extract::{DefaultBodyLimit, Path, Query, State};
 use axum::http::StatusCode;
 use axum::response::{IntoResponse, Response};
 use axum::routing::{any, delete, get, post};
@@ -71,10 +70,6 @@ pub fn router(state: LocalApiState) -> Router {
         .route(routes::patterns::STRUCTURED, any(structured_ws))
         .route(routes::patterns::STRUCTURED_REPLAY, get(structured_replay))
         .route(routes::patterns::STRUCTURED_PROMPT, post(structured_prompt))
-        .route(
-            routes::patterns::STRUCTURED_ATTACHMENT,
-            post(structured_attachment).layer(DefaultBodyLimit::max(20 * 1024 * 1024)),
-        )
         .route(routes::patterns::STRUCTURED_CANCEL, post(structured_cancel))
         .route(routes::patterns::STRUCTURED_CONFIG, post(structured_config))
         .route(
@@ -437,46 +432,6 @@ async fn structured_replay(
     }
 }
 
-#[derive(Deserialize)]
-struct AttachmentQuery {
-    name: String,
-}
-
-async fn structured_attachment(
-    State(s): State<LocalApiState>,
-    Path(id): Path<Uuid>,
-    Query(query): Query<AttachmentQuery>,
-    bytes: Bytes,
-) -> Response {
-    let name = query.name;
-    if name.is_empty()
-        || name.len() > 180
-        || name == "."
-        || name == ".."
-        || name
-            .chars()
-            .any(|c| c.is_control() || c == '/' || c == '\\')
-    {
-        return error_response(
-            StatusCode::BAD_REQUEST,
-            "invalid_filename",
-            "use a filename without directory separators, up to 180 bytes",
-        );
-    }
-    match s.manager.store_acp_attachment(id, &name, &bytes).await {
-        Ok(Some(path)) => Json(serde_json::json!({ "path": path })).into_response(),
-        Ok(None) => error_response(
-            StatusCode::CONFLICT,
-            "not_structured",
-            "session is not a live structured session",
-        ),
-        Err(e) => {
-            let info = e.to_error_info();
-            error_response(session_error_status(&info.code), &info.code, &info.message)
-        }
-    }
-}
-
 async fn structured_prompt(
     State(s): State<LocalApiState>,
     Path(id): Path<Uuid>,

crates/maestro-daemon/src/session.rs

@@ -607,36 +607,6 @@ impl SessionManager {
         Ok(Some(replay))
     }
 
-    /// Store attachment bytes for a live structured session.
-    pub async fn store_acp_attachment(
-        &self,
-        id: Uuid,
-        name: &str,
-        bytes: &[u8],
-    ) -> Result<Option<std::path::PathBuf>, SessionError> {
-        {
-            let sessions = self.inner.sessions.lock().await;
-            let record = sessions.get(&id).ok_or(SessionError::NotFound(id))?;
-            if !record.is_live_structured() {
-                return Ok(None);
-            }
-        }
-        let dir = self.inner.sidecar.dir().join(format!("{id}.attachments"));
-        tokio::fs::create_dir_all(&dir).await?;
-        let dir = tokio::fs::canonicalize(dir).await?;
-        let path = dir.join(format!("{}-{name}", Uuid::new_v4()));
-        let mut file = tokio::fs::OpenOptions::new()
-            .write(true)
-            .create_new(true)
-            .mode(0o600)
-            .open(&path)
-            .await?;
-        use tokio::io::AsyncWriteExt;
-        file.write_all(bytes).await?;
-        file.sync_all().await?;
-        Ok(Some(path))
-    }
-
     /// Subscribe to the two projections of a structured session's ACP log.
     ///
     /// The transcript snapshot and whole reduced state are folded once by the

crates/maestro-daemon/tests/local_api.rs

@@ -235,60 +235,6 @@ async fn structured_ws_sends_snapshot_then_live_projection() {
     );
 }
 
-#[tokio::test]
-async fn structured_attachments_preserve_bytes_and_reject_paths() {
-    let h = spawn("attachments").await;
-    let fake = FakeAcp::new();
-    let id = structured_session(&h, &fake).await;
-    let client = reqwest::Client::new();
-    let endpoint = url(
-        h.addr,
-        &format!("/api/sessions/{id}/structured/attachments"),
-    );
-    let bytes = vec![0, 255, 10, 13];
-    let response = client
-        .post(&endpoint)
-        .query(&[("name", "sample.bin")])
-        .body(bytes.clone())
-        .send()
-        .await
-        .unwrap();
-    assert_eq!(response.status(), 200);
-    let body: serde_json::Value = response.json().await.unwrap();
-    let path = body["path"].as_str().unwrap();
-    assert!(Path::new(path).is_absolute());
-    assert_eq!(std::fs::read(path).unwrap(), bytes);
-    for name in ["../escape", "a/b", "a\\b", "..", ""] {
-        let response = client
-            .post(&endpoint)
-            .query(&[("name", name)])
-            .body("text")
-            .send()
-            .await
-            .unwrap();
-        assert_eq!(response.status(), 400, "{name}");
-    }
-    let response = client
-        .post(&endpoint)
-        .query(&[("name", "large.bin")])
-        .body(vec![0; 20 * 1024 * 1024 + 1])
-        .send()
-        .await
-        .unwrap();
-    assert_eq!(response.status(), 413);
-    let response = client
-        .post(url(
-            h.addr,
-            &format!("/api/sessions/{}/structured/attachments", Uuid::new_v4()),
-        ))
-        .query(&[("name", "file.txt")])
-        .body("text")
-        .send()
-        .await
-        .unwrap();
-    assert_eq!(response.status(), 404);
-}
-
 #[tokio::test]
 async fn structured_prompt_rejects_a_second_in_flight_turn_and_cancel_clears_it() {
     let h = spawn("naps-laptop").await;

crates/maestro-protocol/src/display.rs

@@ -226,15 +226,6 @@ pub fn command_tool(command: &str) -> Option<&'static str> {
         .map(|(_, tool)| *tool)
 }
 
-/// Whether a command line resolves to an agent Maestro can run as a
-/// structured (ACP) session — Claude Code or Codex, the two adapters
-/// `docs/STRUCTURED-VIEW.md` lists. Every client gates its structured-view
-/// control on this, and the daemon rejects a `Structured` request for
-/// anything else, so the answer has to come from one place.
-pub fn supports_structured_view(command: &str) -> bool {
-    matches!(command_tool(command), Some("claude" | "codex"))
-}
-
 /// [`resolve`]'s outcome: the tokenized command line, and the index within it
 /// of the word that is the actual program (past every assignment/wrapper it
 /// resolved through).
@@ -1073,14 +1064,4 @@ mod tests {
         assert_eq!(tokenize("\"FOO=1\" claude").unwrap()[0].plain_eq, None);
         assert_eq!(tokenize("FOO\\=1 claude").unwrap()[0].plain_eq, None);
     }
-
-    #[test]
-    fn structured_view_support_follows_the_resolved_program() {
-        assert!(supports_structured_view("claude --resume"));
-        assert!(supports_structured_view("FOO=1 /usr/local/bin/codex exec"));
-        assert!(supports_structured_view("npx claude-code"));
-        assert!(!supports_structured_view("opencode"));
-        assert!(!supports_structured_view("bash -l"));
-        assert!(!supports_structured_view("claude-code-acp"));
-    }
 }

crates/maestro-protocol/src/routes.rs

@@ -86,11 +86,6 @@ pub fn structured_prompt(id: Uuid) -> String {
     format!("{SESSIONS}/{id}/structured/prompt")
 }
 
-/// `POST /api/sessions/:id/structured/attachments` — upload a file.
-pub fn structured_attachment(id: Uuid) -> String {
-    format!("{SESSIONS}/{id}/structured/attachments")
-}
-
 /// `POST /api/sessions/:id/structured/cancel` — cancel an ACP turn.
 pub fn structured_cancel(id: Uuid) -> String {
     format!("{SESSIONS}/{id}/structured/cancel")
@@ -118,7 +113,6 @@ pub mod patterns {
     pub const STRUCTURED: &str = "/api/structured/:id";
     pub const STRUCTURED_REPLAY: &str = "/api/sessions/:id/structured/replay";
     pub const STRUCTURED_PROMPT: &str = "/api/sessions/:id/structured/prompt";
-    pub const STRUCTURED_ATTACHMENT: &str = "/api/sessions/:id/structured/attachments";
     pub const STRUCTURED_CANCEL: &str = "/api/sessions/:id/structured/cancel";
     pub const STRUCTURED_CONFIG: &str = "/api/sessions/:id/structured/config";
     pub const STRUCTURED_APPROVAL: &str = "/api/sessions/:id/structured/approvals/:nonce";

crates/maestro-tui/src/app.rs

@@ -11,7 +11,6 @@
 //! `dispatch` / the overlay routing.
 
 use std::collections::{HashMap, HashSet};
-use std::io::Write;
 use std::path::PathBuf;
 use std::time::Duration;
 
@@ -55,36 +54,6 @@ enum OverlayDecision {
     Pass,
 }
 
-fn copy_to_terminal_clipboard(text: &str) -> std::io::Result<()> {
-    let encoded = base64_encode(text.as_bytes());
-    let mut output = std::io::stdout();
-    write!(output, "\x1b]52;c;{encoded}\x07")?;
-    output.flush()
-}
-
-fn base64_encode(bytes: &[u8]) -> String {
-    const TABLE: &[u8; 64] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-    let mut output = String::with_capacity(bytes.len().div_ceil(3) * 4);
-    for chunk in bytes.chunks(3) {
-        let bits = (u32::from(chunk[0]) << 16)
-            | (u32::from(*chunk.get(1).unwrap_or(&0)) << 8)
-            | u32::from(*chunk.get(2).unwrap_or(&0));
-        output.push(TABLE[((bits >> 18) & 0x3f) as usize] as char);
-        output.push(TABLE[((bits >> 12) & 0x3f) as usize] as char);
-        output.push(if chunk.len() > 1 {
-            TABLE[((bits >> 6) & 0x3f) as usize] as char
-        } else {
-            '='
-        });
-        output.push(if chunk.len() > 2 {
-            TABLE[(bits & 0x3f) as usize] as char
-        } else {
-            '='
-        });
-    }
-    output
-}
-
 pub struct App {
     cfg: TuiConfig,
     home_dir: String,
@@ -371,10 +340,6 @@ impl App {
             return Ok(false);
         }
 
-        if self.handle_structured_mouse(&key) {
-            return Ok(false);
-        }
-
         if let Some(effects) = self.handle_structured_key(&key) {
             self.perform(effects).await;
             return Ok(false);
@@ -458,61 +423,6 @@ impl App {
         true
     }
 
-    /// Transcript blocks are pointer targets: click selects the whole block,
-    /// gives it the selection surface, and copies its complete text.
-    fn handle_structured_mouse(&mut self, key: &InputKey) -> bool {
-        let InputKey::Mouse {
-            kind,
-            region: Region::Pane,
-            row,
-            ..
-        } = key
-        else {
-            return false;
-        };
-        if !matches!(kind, MouseKind::Click | MouseKind::Hover) {
-            return false;
-        }
-        let Some(sid) = self.state.active_session() else {
-            return false;
-        };
-        let Some(handle) = self.structured.get(&sid) else {
-            return false;
-        };
-        let Some(pane) = self.region.pane else {
-            return false;
-        };
-        let offset = usize::from(row.saturating_sub(pane.y));
-        let transcript_height = pane.height.saturating_sub(pane.height.min(3));
-        if offset >= usize::from(transcript_height) {
-            return true;
-        }
-        let mut state = handle.state.lock().expect("structured state mutex");
-        let rendered_line = state.scroll.saturating_add(offset);
-        if !state.select_rendered_line(rendered_line) {
-            return true;
-        }
-        let Some(id) = state.selected.as_deref() else {
-            return true;
-        };
-        let Some(transcript) = state.rows.iter().find(|item| item.id == id) else {
-            return true;
-        };
-        if *kind == MouseKind::Hover {
-            return true;
-        }
-        let text = crate::structured_pane::copy_text(transcript);
-        drop(state);
-        if text.is_empty() {
-            return true;
-        }
-        match copy_to_terminal_clipboard(&text) {
-            Ok(()) => self.state.toast("copied transcript block"),
-            Err(error) => self.state.toast(format!("copy failed: {error}")),
-        }
-        true
-    }
-
     /// Carry out what `dispatch` decided. The only place in `App` that talks to
     /// the daemon.
     async fn perform(&mut self, effects: Vec<Effect>) {
@@ -1995,12 +1905,6 @@ async fn fetch_branches(
 #[cfg(test)]
 mod tests {
     use super::*;
-
-    #[test]
-    fn clipboard_payload_uses_standard_base64() {
-        assert_eq!(base64_encode(b"hello"), "aGVsbG8=");
-        assert_eq!(base64_encode("✓".as_bytes()), "4pyT");
-    }
     use crate::action::Action;
     use crate::draft::DraftField;
     use crate::keymap::Mode;

crates/maestro-tui/src/draft.rs

@@ -41,7 +41,7 @@ use std::time::{Duration, Instant};
 
 use chrono::{DateTime, Utc};
 use maestro_config::{builtin_presets, custom_preset};
-use maestro_protocol::display::{abbreviate_dir, supports_structured_view};
+use maestro_protocol::display::{abbreviate_dir, command_tool};
 use maestro_protocol::{
     BranchInfo, CreateSessionRequest, Project, SessionView, SpawnPreset, WorktreeSpec,
 };
@@ -255,14 +255,9 @@ pub struct DraftPane {
     /// "Advanced options" disclosure (#93). Closed by default — most spawns
     /// take the default target.
     pub advanced_collapsed: bool,
-    /// ACP-backed structured transcript. Supported only when the resolved
+    /// ACP-backed structured transcript. Off by default and supported only
-    /// command is Claude Code or Codex, and on by default whenever it is —
+    /// when the resolved command is Claude Code or Codex.
-    /// until the operator works the toggle themselves.
     pub structured_view: bool,
-    /// Set once the operator toggles structured view by hand. From then on a
-    /// command change never re-enables what they turned off, the same guard
-    /// `name_touched` gives the name field.
-    pub structured_view_touched: bool,
     /// Enclosing repository of the chosen target — from the project scan for
     /// picked rows, `/api/gitroot` for raw paths. `None` until known.
     pub base_repo: Option<PathBuf>,
@@ -303,7 +298,7 @@ impl Default for DraftPane {
         // while its data loads, and stay usable when the daemon reports none.
         let mut presets = builtin_presets();
         presets.push(custom_preset());
-        let mut draft = Self {
+        Self {
             id: NEXT_DRAFT_ID.fetch_add(1, std::sync::atomic::Ordering::Relaxed),
             presets,
             selected_preset: 0,
@@ -324,7 +319,6 @@ impl Default for DraftPane {
             worktree_enabled: true,
             advanced_collapsed: true,
             structured_view: false,
-            structured_view_touched: false,
             base_repo: None,
             probed_cwd: None,
             probe_seq: 0,
@@ -343,11 +337,7 @@ impl Default for DraftPane {
             // straight away, and Tab from here reaches the command tiles.
             focused_field: DraftField::DirPicker,
             home_dir: String::new(),
-        };
+        }
-        // The built-in tile the form opens on decides whether structured view
-        // starts ticked, exactly as a later preset list would.
-        draft.sync_structured_view();
-        draft
     }
 }
 
@@ -366,7 +356,7 @@ impl DraftPane {
             .position(|p| !p.command.is_empty())
             .unwrap_or(0);
         self.apply_seed_command();
-        self.sync_structured_view();
+        self.clear_unsupported_structured_view();
     }
 
     /// Land a seeded command on the tile that runs it: its own preset when the
@@ -683,24 +673,18 @@ impl DraftPane {
     }
 
     fn supports_structured_view(&self) -> bool {
-        supports_structured_view(self.command())
+        matches!(command_tool(self.command()), Some("claude" | "codex"))
     }
 
-    /// Re-resolve the toggle after the command changed: an unsupported
+    fn clear_unsupported_structured_view(&mut self) {
-    /// command forces it off, a supported one turns it back on unless the
-    /// operator has already made the choice themselves.
-    fn sync_structured_view(&mut self) {
         if !self.supports_structured_view() {
             self.structured_view = false;
-        } else if !self.structured_view_touched {
-            self.structured_view = true;
         }
     }
 
     pub fn toggle_structured_view(&mut self) {
         if self.supports_structured_view() {
             self.structured_view = !self.structured_view;
-            self.structured_view_touched = true;
         }
     }
 
@@ -848,7 +832,7 @@ impl DraftPane {
         }
         self.selected_preset =
             ((self.selected_preset as i32) + delta).rem_euclid(len as i32) as usize;
-        self.sync_structured_view();
+        self.clear_unsupported_structured_view();
     }
 
     /// Step-one boxes surviving the type-to-filter, in display order. A
@@ -1151,7 +1135,7 @@ impl DraftPane {
                     DraftField::Preset | DraftField::Submit => {}
                     DraftField::CustomCommand => {
                         self.custom_command.handle_key(other);
-                        self.sync_structured_view();
+                        self.clear_unsupported_structured_view();
                     }
                     // Typing filters the list; the highlight resets to the top
                     // so a narrowed search always starts at its best match.
@@ -1913,7 +1897,7 @@ mod tests {
     }
 
     #[test]
-    fn structured_view_is_default_on_and_visible_for_supported_agents() {
+    fn structured_view_is_default_off_and_visible_for_supported_agents() {
         let mut draft = DraftPane {
             advanced_collapsed: false,
             ..DraftPane::default()
@@ -1938,11 +1922,13 @@ mod tests {
                 auto_approve: false,
             },
         ]);
-        assert!(draft.structured_view, "on by default for a supported agent");
+        assert!(!draft.structured_view);
         assert!(draft.field_order().contains(&DraftField::StructuredToggle));
         let rendered = render_to_string(100, 24, |f| draft.render(f, f.area(), true));
-        assert!(rendered.contains("[x] structured view"), "{rendered}");
+        assert!(rendered.contains("[ ] structured view"), "{rendered}");
 
+        draft.toggle_structured_view();
+        assert!(draft.structured_view);
         draft.cycle_preset(1);
         assert_eq!(draft.command(), "codex");
         assert!(
@@ -2032,16 +2018,16 @@ mod tests {
             };
             draft.selected_preset = draft.presets.len() - 1;
             draft.custom_command = crate::text_input::TextInput::with_value(command);
-            draft.sync_structured_view();
 
             assert_eq!(
                 draft.field_order().contains(&DraftField::StructuredToggle),
                 supported,
                 "toggle visibility for {command:?}"
             );
+            draft.toggle_structured_view();
             assert_eq!(
                 draft.structured_view, supported,
-                "default selection for {command:?}"
+                "toggle takes effect for {command:?}"
             );
             let view = draft.build_request().unwrap().view;
             assert_eq!(
@@ -2053,12 +2039,6 @@ mod tests {
                 },
                 "request view for {command:?}"
             );
-
-            draft.toggle_structured_view();
-            assert!(
-                !draft.structured_view,
-                "the toggle turns the default off for {command:?}"
-            );
         }
     }
 
@@ -2096,6 +2076,7 @@ mod tests {
 
         assert_eq!(draft.command(), "npx claude-code --resume");
         assert!(draft.field_order().contains(&DraftField::StructuredToggle));
+        draft.toggle_structured_view();
         assert!(draft.structured_view);
         assert_eq!(draft.build_request().unwrap().view, SessionView::Structured);
 
@@ -2114,45 +2095,6 @@ mod tests {
         assert_eq!(draft.build_request().unwrap().view, SessionView::Terminal);
     }
 
-    /// The default only applies until the operator has an opinion: once they
-    /// untick the box, moving between supported commands leaves it unticked
-    /// instead of turning it back on under them.
-    #[test]
-    fn an_unticked_structured_view_survives_a_command_change() {
-        let mut draft = DraftPane {
-            picked_cwd: Some(PathBuf::from("/srv/work")),
-            worktree_enabled: false,
-            advanced_collapsed: false,
-            ..DraftPane::default()
-        };
-        draft.set_presets(vec![
-            SpawnPreset {
-                id: "claude".into(),
-                label: "Claude".into(),
-                command: "claude".into(),
-                auto_approve: false,
-            },
-            SpawnPreset {
-                id: "codex".into(),
-                label: "Codex".into(),
-                command: "codex".into(),
-                auto_approve: false,
-            },
-        ]);
-        assert!(draft.structured_view);
-
-        draft.toggle_structured_view();
-        assert!(!draft.structured_view);
-
-        draft.cycle_preset(1);
-        assert_eq!(draft.command(), "codex");
-        assert!(
-            !draft.structured_view,
-            "the operator's choice outranks the default"
-        );
-        assert_eq!(draft.build_request().unwrap().view, SessionView::Terminal);
-    }
-
     /// Editing the custom-command text away from a supported agent clears an armed
     /// selection immediately, matching the preset-switch case above — an
     /// invalid `Structured` request can never reach `build_request`.
@@ -2167,7 +2109,7 @@ mod tests {
         };
         draft.selected_preset = draft.presets.len() - 1;
         draft.custom_command = crate::text_input::TextInput::with_value("codex");
-        draft.sync_structured_view();
+        draft.toggle_structured_view();
         assert!(draft.structured_view);
 
         typed(&mut draft, " -p");

crates/maestro-tui/src/input.rs

@@ -55,7 +55,6 @@ pub enum MouseKind {
     Click,
     DblClick,
     Drag,
-    Hover,
     ScrollUp,
     ScrollDown,
 }
@@ -149,7 +148,6 @@ impl InputKey {
                     MouseKind::Click => "click",
                     MouseKind::DblClick => "dblclick",
                     MouseKind::Drag => "drag",
-                    MouseKind::Hover => "hover",
                     MouseKind::ScrollUp => "scrollup",
                     MouseKind::ScrollDown => "scrolldown",
                 };
@@ -180,7 +178,6 @@ impl InputKey {
                 "click" => MouseKind::Click,
                 "dblclick" => MouseKind::DblClick,
                 "drag" => MouseKind::Drag,
-                "hover" => MouseKind::Hover,
                 "scrollup" => MouseKind::ScrollUp,
                 "scrolldown" => MouseKind::ScrollDown,
                 other => return Err(InputParseError::UnknownMouseKind(other.into())),
@@ -300,7 +297,6 @@ where
             let mk = match kind {
                 MouseEventKind::Down(MouseButton::Left) => MouseKind::Click,
                 MouseEventKind::Drag(MouseButton::Left) => MouseKind::Drag,
-                MouseEventKind::Moved => MouseKind::Hover,
                 MouseEventKind::ScrollUp => MouseKind::ScrollUp,
                 MouseEventKind::ScrollDown => MouseKind::ScrollDown,
                 _ => return None,
@@ -685,9 +681,6 @@ mod tests {
         let s = "mouse:dblclick(sidebar-row)";
         let k = InputKey::parse(s).unwrap();
         assert_eq!(k.canonical(), s);
-        let s = "mouse:hover(pane)";
-        let k = InputKey::parse(s).unwrap();
-        assert_eq!(k.canonical(), s);
     }
 
     #[test]

crates/maestro-tui/src/structured_pane.rs

@@ -308,12 +308,11 @@ fn fallback_after_removal(
 
 fn build_lines(state: &StructuredState, width: usize) -> Vec<VisualLine> {
     let mut out = Vec::new();
-    for (index, row) in state.rows.iter().enumerate() {
+    for row in &state.rows {
         if row.kind == TranscriptRowKind::Plan {
             continue;
         }
         let row_width = width.saturating_sub(1).max(1);
-        let start = out.len();
         match row.kind {
             TranscriptRowKind::User => push_wrapped(
                 &mut out,
@@ -357,53 +356,10 @@ fn build_lines(state: &StructuredState, width: usize) -> Vec<VisualLine> {
             ),
             TranscriptRowKind::Plan => {}
         }
-        if out.len() > start
-            && state.rows[index + 1..]
-                .iter()
-                .any(|next| next.kind != TranscriptRowKind::Plan)
-        {
-            // A blank surface line is the vertical padding that keeps adjacent
-            // transcript blocks readable at a glance.
-            out.push(VisualLine {
-                text: String::new(),
-                row_id: None,
-                rail: false,
-                tone: Tone::Normal,
-            });
-        }
     }
     out
 }
 
-/// Text supplied to the terminal clipboard when a transcript block is
-/// clicked. It preserves the full tool detail rather than its compact preview.
-pub fn copy_text(row: &TranscriptRow) -> String {
-    match row.kind {
-        TranscriptRowKind::User
-        | TranscriptRowKind::AgentText
-        | TranscriptRowKind::AgentThought => content_text(row),
-        TranscriptRowKind::ToolCall | TranscriptRowKind::ToolDiff => {
-            let (name, argument) = tool_title(row);
-            let mut lines = vec![if argument.is_empty() {
-                name
-            } else {
-                format!("{name}  {argument}")
-            }];
-            lines.extend(tool_content_lines(row, None));
-            lines.join("\n")
-        }
-        TranscriptRowKind::Approval => row
-            .data
-            .get("toolCall")
-            .and_then(|tool| tool.get("title"))
-            .and_then(serde_json::Value::as_str)
-            .unwrap_or("permission requested")
-            .into(),
-        TranscriptRowKind::Notice => "[notice]".into(),
-        TranscriptRowKind::Plan => String::new(),
-    }
-}
-
 fn push_wrapped(
     out: &mut Vec<VisualLine>,
     row: &TranscriptRow,
@@ -1044,39 +1000,6 @@ mod tests {
         );
     }
 
-    #[test]
-    fn transcript_blocks_have_a_padding_line_between_them() {
-        let mut state = StructuredState::default();
-        state.rows = vec![
-            row(
-                "one",
-                TranscriptRowKind::User,
-                json!({"content":{"type":"text","text":"first"}}),
-            ),
-            row(
-                "two",
-                TranscriptRowKind::AgentText,
-                json!({"content":{"type":"text","text":"second"}}),
-            ),
-        ];
-
-        let lines = build_lines(&state, 80);
-        assert_eq!(lines.len(), 3);
-        assert_eq!(lines[1].text, "");
-        assert!(lines[1].row_id.is_none());
-    }
-
-    #[test]
-    fn copying_a_tool_keeps_its_full_detail() {
-        let tool = row(
-            "t",
-            TranscriptRowKind::ToolCall,
-            json!({"title":"Bash(cargo test)","content":[{"type":"content","content":{"type":"text","text":"all green"}}]}),
-        );
-
-        assert_eq!(copy_text(&tool), "Bash  cargo test\nall green");
-    }
-
     #[test]
     fn tool_is_compact_until_selected_row_expands() {
         let mut state = StructuredState::default();
@@ -1497,7 +1420,7 @@ mod tests {
         let mut state = StructuredState::default();
         state.follow_selection = false;
         numbered_rows(&mut state, 20);
-        state.scroll = 20;
+        state.scroll = 10;
 
         let before = render_transcript_lines(&pane, &mut state, 30, 5);
         assert!(before[0].contains("line 10"), "{before:?}");
@@ -1516,7 +1439,7 @@ mod tests {
         let mut state = StructuredState::default();
         state.follow_selection = false;
         numbered_rows(&mut state, 20);
-        state.scroll = 20;
+        state.scroll = 10;
 
         let before = render_transcript_lines(&pane, &mut state, 30, 5);
         assert!(before[0].contains("line 10"), "{before:?}");
@@ -1536,7 +1459,7 @@ mod tests {
         let mut state = StructuredState::default();
         state.follow_selection = false;
         numbered_rows(&mut state, 20);
-        state.scroll = 20;
+        state.scroll = 10;
 
         let before = render_transcript_lines(&pane, &mut state, 30, 5);
         assert!(before[0].contains("line 10"), "{before:?}");
@@ -1555,7 +1478,7 @@ mod tests {
         let mut state = StructuredState::default();
         state.follow_selection = false;
         numbered_rows(&mut state, 20);
-        state.scroll = 20;
+        state.scroll = 10;
 
         let before = render_transcript_lines(&pane, &mut state, 30, 5);
         assert!(before[0].contains("line 10"), "{before:?}");
@@ -1574,7 +1497,7 @@ mod tests {
         let mut state = StructuredState::default();
         state.follow_selection = false;
         numbered_rows(&mut state, 20);
-        state.scroll = 20;
+        state.scroll = 10;
 
         render_transcript_lines(&pane, &mut state, 30, 5);
         // Simulate a `TranscriptDelta::Patch` on a collapsed tool row above the

crates/maestro-tui/src/structured_task.rs

@@ -199,18 +199,6 @@ impl StructuredState {
         self.follow_selection = true;
     }
 
-    /// Select the transcript block under a rendered transcript line. Pointer
-    /// input uses the same row identity map as scroll reconciliation, so a
-    /// wrapped block behaves as one target.
-    pub fn select_rendered_line(&mut self, line: usize) -> bool {
-        let Some(id) = self.line_rows.get(line).and_then(Clone::clone) else {
-            return false;
-        };
-        self.selected = Some(id);
-        self.follow_selection = false;
-        true
-    }
-
     pub fn toggle_selected(&mut self) {
         let Some(id) = self.selected.clone() else {
             return;
@@ -669,25 +657,6 @@ mod tests {
         assert_eq!(state.composer.value(), "hi");
     }
 
-    #[test]
-    fn selecting_a_rendered_line_selects_its_whole_block() {
-        let mut state = StructuredState {
-            line_rows: vec![
-                Some("one".into()),
-                Some("one".into()),
-                None,
-                Some("two".into()),
-            ],
-            ..Default::default()
-        };
-
-        assert!(state.select_rendered_line(1));
-        assert_eq!(state.selected.as_deref(), Some("one"));
-        assert!(!state.follow_selection);
-        assert!(!state.select_rendered_line(2));
-        assert_eq!(state.selected.as_deref(), Some("one"));
-    }
-
     #[test]
     fn authoritative_idle_snapshot_reconciles_a_wholly_missed_turn() {
         let mut state = StructuredState::default();

docs/STRUCTURED-VIEW.md

@@ -35,22 +35,6 @@ session's worktree holds unsaved work — applies to a structured session
 exactly as it does to a terminal one; only what gets terminated differs (an
 ACP handle instead of a tmux pane).
 
-## Choosing the view
-
-`view` is fixed at spawn and never changes. Every client picks it the same
-way, from the resolved command alone
-(`maestro_protocol::display::supports_structured_view`): a command that
-resolves to Claude Code or Codex spawns **Structured** by default, anything
-else spawns **Terminal**. The operator can override the default — the web and
-TUI spawn forms show the checkbox ticked and let it be unticked, and
-`maestro spawn` takes `--terminal` (or `--structured`, which sends the request
-even for a command the CLI does not recognise and lets the daemon refuse it).
-Once the operator works the toggle, a later command change never re-ticks it
-under them; it can still be forced off when the new command has no adapter.
-
-The daemon is the last word: a `Structured` request for a command with no
-adapter is refused there, whichever client sent it.
-
 ## The adapter
 
 The resolved structured command selects a provider adapter. Its binary is
@@ -318,26 +302,6 @@ pending decision, entirely on the daemon side:
 
 ## Prompt and cancel: bounded liveness
 
-The web composer accepts up to ten files through its attachment picker, file
-drop, or clipboard. Pasted text of at least 4,000 characters or 40 lines becomes
-a UTF-8 `.txt` attachment. Shorter pastes stay in the composer. Attachments can
-be removed before sending; failed sends retain the draft and attachments.
-Pastes also stay inline when all ten attachment slots are occupied or the text
-exceeds the 20 MiB file limit.
-
-On send, `POST /api/sessions/:id/structured/attachments?name=<filename>` uploads
-each file as raw bytes (20 MiB maximum) and returns its absolute `path`.
-Only live structured sessions accept uploads. Filenames are limited to 180
-bytes and cannot contain directory separators or control characters. Files get unique names and private
-file permissions in `<id>.attachments` beside the session sidecar. They persist
-across daemon restarts; removing a composer chip does not delete uploaded data.
-There is currently no automatic attachment cleanup.
-
-The prompt includes each filename and host path so the adapter can read it
-through its own file tools, including images when the provider supports them.
-These references are persisted in the ordinary user transcript row. Attachment
-bytes are not embedded in ACP messages or transcript history.
-
 `POST /api/sessions/:id/structured/prompt` and `.../cancel` are serialized
 against each other through one per-session `operation` lock
 (`AcpEventStream::operation`), because ACP permission callbacks carry no

web/src/api.ts

@@ -184,15 +184,6 @@ export async function sendStructuredPrompt(id: Uuid, prompt: string): Promise<vo
   );
 }
 
-export async function uploadStructuredFile(id: Uuid, file: File): Promise<{ path: string }> {
-  return jsonOrError(await fetch(`${routes.structuredAttachment(id)}?name=${encodeURIComponent(file.name)}`, {
-    method: "POST",
-    credentials: "same-origin",
-    headers: { "content-type": "application/octet-stream" },
-    body: file,
-  }));
-}
-
 /** Cancel a structured session's active ACP turn (#138). */
 export async function cancelStructuredTurn(id: Uuid): Promise<void> {
   await jsonOrError(

web/src/routes.ts

@@ -47,10 +47,6 @@ export function structuredPrompt(id: Uuid): string {
   return `${session(id)}/structured/prompt`;
 }
 
-export function structuredAttachment(id: Uuid): string {
-  return `${session(id)}/structured/attachments`;
-}
-
 /** `POST /api/sessions/:id/structured/cancel` — cancel an ACP turn. */
 export function structuredCancel(id: Uuid): string {
   return `${session(id)}/structured/cancel`;

web/src/spawnForm.ts

@@ -157,20 +157,20 @@ export function createSpawnForm(opts: SpawnFormOptions): SpawnFormHandle {
       <input class="raw-input cmd-raw" name="command_raw" type="text" hidden
              placeholder="bash -l" autocomplete="off" />
     </div>
-    <div class="advanced">
+    <div class="field">
+      <span class="field-label">Name</span>
+      <div class="name-row">
+        <input name="name" type="text" autocomplete="off"
+               placeholder="named after your first prompt" />
+      </div>
+    </div>
+    <fieldset class="worktree">
       <button type="button" class="tree-folder-header wt-toggle" aria-expanded="false">
         <span class="chevron">▾</span>
-        <span class="folder-name">Advanced</span>
+        <span class="folder-name">Advanced options</span>
         <span class="wt-summary"></span>
       </button>
       <div class="wt-collapsible" hidden>
-        <div class="field">
-          <span class="field-label">Session name</span>
-          <div class="name-row">
-            <input name="name" type="text" autocomplete="off"
-                   placeholder="named after your first prompt" />
-          </div>
-        </div>
         <label class="row-inline structured-view" hidden>
           <input type="checkbox" name="structured_view" />
           Structured view
@@ -179,36 +179,34 @@ export function createSpawnForm(opts: SpawnFormOptions): SpawnFormHandle {
           <span class="field-label">Worktree</span>
           <div class="picker wt-choices"></div>
         </div>
-        <div class="adv-group">
+        <label class="row-inline">
-          <label class="row-inline">
+          <input type="checkbox" name="worktree_enabled" />
-            <input type="checkbox" name="worktree_enabled" />
+          Create git worktree
-            Create git worktree
+        </label>
-          </label>
+        <p class="wt-hint" hidden></p>
-          <p class="wt-hint" hidden></p>
+        <div class="wt-body" hidden>
-          <div class="wt-body" hidden>
+          <p class="wt-repo"></p>
-            <p class="wt-repo"></p>
+          <div class="wt-mode" role="radiogroup" aria-label="Branch source">
-            <div class="wt-mode" role="radiogroup" aria-label="Branch source">
+            <label class="row-inline">
-              <label class="row-inline">
+              <input type="radio" name="worktree_branch_mode" value="new" />
-                <input type="radio" name="worktree_branch_mode" value="new" />
+              New branch
-                New branch
-              </label>
-              <label class="row-inline">
-                <input type="radio" name="worktree_branch_mode" value="existing" />
-                Existing branch
-              </label>
-            </div>
-            <label class="wt-new-wrap">
-              New branch name
-              <input name="worktree_branch" type="text" placeholder="feat/foo" autocomplete="off" />
             </label>
-            <label class="wt-exist-wrap" hidden>
+            <label class="row-inline">
-              Pick a branch
+              <input type="radio" name="worktree_branch_mode" value="existing" />
-              <select class="branch-select"></select>
+              Existing branch
             </label>
           </div>
+          <label class="wt-new-wrap">
+            New branch name
+            <input name="worktree_branch" type="text" placeholder="feat/foo" autocomplete="off" />
+          </label>
+          <label class="wt-exist-wrap" hidden>
+            Pick a branch
+            <select class="branch-select"></select>
+          </label>
         </div>
       </div>
-    </div>
+    </fieldset>
     <p class="form-error" role="alert" aria-live="polite"></p>
     <div class="form-actions">
       <button type="submit" class="btn btn-primary">Spawn</button>
@@ -385,23 +383,13 @@ export function createSpawnForm(opts: SpawnFormOptions): SpawnFormHandle {
   // operator has already touched (#76).
   let commandTouched = false;
 
-  // Set once the operator works the checkbox themselves. Until then every
-  // command change re-derives the default (on for Claude Code and Codex, off
-  // for everything else); afterwards their choice outranks it, the same guard
-  // `commandTouched` gives the command field.
-  let structuredTouched = false;
-
   function updateStructuredAvailability(): void {
     const supported = supportsStructuredView(command);
     structuredWrap.hidden = !supported;
     if (!supported) structuredView.checked = false;
-    else if (!structuredTouched) structuredView.checked = true;
   }
 
-  structuredView.addEventListener("change", () => {
+  structuredView.addEventListener("change", emit);
-    structuredTouched = true;
-    emit();
-  });
 
   cmdRaw.addEventListener("input", () => {
     if (selectedPresetId === "custom" || presets.find((p) => p.id === selectedPresetId)?.command === "") {

web/src/spawnFormStructured.test.ts

@@ -44,7 +44,7 @@ describe("spawn form structured view", () => {
     vi.unstubAllGlobals();
   });
 
-  it("is default-on and shown for resolved Claude Code and Codex commands", async () => {
+  it("is default-off and shown for resolved Claude Code and Codex commands", async () => {
     stubApi();
     handle = createSpawnForm({ onSuccess() {} });
     document.body.appendChild(handle.el);
@@ -57,7 +57,7 @@ describe("spawn form structured view", () => {
     handle.el.querySelector<HTMLButtonElement>(".wt-toggle")!.click();
     expect(disclosure.hidden).toBe(false);
     expect(wrap.hidden).toBe(false);
-    expect(checkbox.checked).toBe(true);
+    expect(checkbox.checked).toBe(false);
 
     const custom = handle.el.querySelector<HTMLButtonElement>('[data-id="custom"]')!;
     custom.click();
@@ -65,34 +65,13 @@ describe("spawn form structured view", () => {
     command.value = "FOO=1 /usr/local/bin/codex";
     command.dispatchEvent(new Event("input"));
     expect(wrap.hidden).toBe(false);
-    expect(checkbox.checked).toBe(true);
 
     command.value = "opencode";
     command.dispatchEvent(new Event("input"));
     expect(wrap.hidden).toBe(true);
-    expect(checkbox.checked).toBe(false);
   });
 
-  it("keeps an unchecked box unchecked across a command change", async () => {
+  it("clears a checked value when Codex changes to an unsupported command", async () => {
-    stubApi();
-    handle = createSpawnForm({ onSuccess() {} });
-    document.body.appendChild(handle.el);
-    await drain();
-
-    const checkbox = handle.el.querySelector<HTMLInputElement>("input[name=structured_view]")!;
-    expect(checkbox.checked).toBe(true);
-    checkbox.click();
-    expect(checkbox.checked).toBe(false);
-
-    handle.el.querySelector<HTMLButtonElement>('[data-id="custom"]')!.click();
-    const command = handle.el.querySelector<HTMLInputElement>(".cmd-raw")!;
-    command.value = "codex";
-    command.dispatchEvent(new Event("input"));
-
-    expect(checkbox.checked).toBe(false);
-  });
-
-  it("clears the checked default when Codex changes to an unsupported command", async () => {
     stubApi();
     handle = createSpawnForm({ onSuccess() {} });
     document.body.appendChild(handle.el);
@@ -104,6 +83,7 @@ describe("spawn form structured view", () => {
     command.dispatchEvent(new Event("input"));
 
     const checkbox = handle.el.querySelector<HTMLInputElement>("input[name=structured_view]")!;
+    checkbox.click();
     expect(checkbox.checked).toBe(true);
 
     command.value = "opencode";
@@ -113,7 +93,7 @@ describe("spawn form structured view", () => {
     expect(checkbox.checked).toBe(false);
   });
 
-  it.each(["claude", "codex"])("emits Structured for a %s command by default", async (tool) => {
+  it.each(["claude", "codex"])("emits Structured for a selected %s command", async (tool) => {
     const requests = stubApi();
     handle = createSpawnForm({
       seed: { cwd: "/srv/work", cwdRawVisible: true, worktreeEnabled: false },
@@ -129,6 +109,7 @@ describe("spawn form structured view", () => {
       command.dispatchEvent(new Event("input"));
     }
 
+    handle.el.querySelector<HTMLInputElement>("input[name=structured_view]")!.click();
     handle.el.requestSubmit();
     await drain();
 
@@ -138,21 +119,4 @@ describe("spawn form structured view", () => {
       view: "Structured",
     });
   });
-
-  it("emits no view once the operator unticks the box", async () => {
-    const requests = stubApi();
-    handle = createSpawnForm({
-      seed: { cwd: "/srv/work", cwdRawVisible: true, worktreeEnabled: false },
-      onSuccess() {},
-    });
-    document.body.appendChild(handle.el);
-    await drain();
-
-    handle.el.querySelector<HTMLInputElement>("input[name=structured_view]")!.click();
-    handle.el.requestSubmit();
-    await drain();
-
-    expect(requests).toHaveLength(1);
-    expect(JSON.parse(String(requests[0].body)).view).toBeUndefined();
-  });
 });

web/src/structured.test.ts

@@ -6,7 +6,6 @@ vi.mock("./api.js", async () => {
   return {
     ...actual,
     sendStructuredPrompt: vi.fn().mockResolvedValue(undefined),
-    uploadStructuredFile: vi.fn().mockResolvedValue({ path: "/uploads/pasted.txt" }),
     cancelStructuredTurn: vi.fn().mockResolvedValue(undefined),
     resolveStructuredApproval: vi.fn().mockResolvedValue(undefined),
     setStructuredConfig: vi.fn().mockResolvedValue(undefined),
@@ -17,7 +16,6 @@ import {
   cancelStructuredTurn,
   resolveStructuredApproval,
   sendStructuredPrompt,
-  uploadStructuredFile,
   setStructuredConfig,
 } from "./api.js";
 import { TOGGLE_DRAWER_EVENT } from "./drawer.js";
@@ -97,53 +95,6 @@ function mount(opts: {
 describe("structured connection: data flow", () => {
   beforeEach(() => vi.clearAllMocks());
 
-  it("converts long pasted text into a removable file and sends it without reply text", async () => {
-    const conn = mount({ sockets: [new FakeSocket()] });
-    const input = conn.el.querySelector("textarea")!;
-    const paste = new Event("paste", { bubbles: true, cancelable: true });
-    Object.defineProperty(paste, "clipboardData", { value: {
-      files: [], getData: () => "a".repeat(4000),
-    } });
-    input.dispatchEvent(paste);
-    expect(paste.defaultPrevented).toBe(true);
-    expect(input.value).toBe("");
-    expect(conn.el.querySelector(".structured-attachments")!.textContent).toContain("pasted-1.txt");
-    conn.el.querySelector("form")!.dispatchEvent(new Event("submit", { cancelable: true }));
-    await vi.waitFor(() => expect(sendStructuredPrompt).toHaveBeenCalledWith("s1", expect.stringContaining("/uploads/pasted.txt")));
-    expect(uploadStructuredFile).toHaveBeenCalledWith("s1", expect.objectContaining({ name: "pasted-1.txt", size: 4000 }));
-    conn.dispose();
-  });
-
-  it("leaves short pastes alone", () => {
-    const conn = mount({ sockets: [new FakeSocket()] });
-    const paste = new Event("paste", { bubbles: true, cancelable: true });
-    Object.defineProperty(paste, "clipboardData", { value: { files: [], getData: () => "hello" } });
-    conn.el.querySelector("textarea")!.dispatchEvent(paste);
-    expect(paste.defaultPrevented).toBe(false);
-    conn.dispose();
-  });
-
-  it("retains failed uploads for retry and lets the operator remove them", async () => {
-    vi.mocked(uploadStructuredFile).mockRejectedValueOnce(new Error("Upload failed"));
-    const conn = mount({ sockets: [new FakeSocket()] });
-    const input = conn.el.querySelector("textarea")!;
-    input.value = "Read this";
-    const paste = new Event("paste", { bubbles: true, cancelable: true });
-    Object.defineProperty(paste, "clipboardData", { value: {
-      files: [new File(["content"], "notes.txt")], getData: () => "",
-    } });
-    input.dispatchEvent(paste);
-    conn.el.querySelector("form")!.dispatchEvent(new Event("submit", { cancelable: true }));
-    await vi.waitFor(() => expect(input.disabled).toBe(false));
-    expect(input.value).toBe("Read this");
-    expect(sendStructuredPrompt).not.toHaveBeenCalled();
-    const remove = conn.el.querySelector<HTMLButtonElement>('[aria-label="Remove notes.txt"]')!;
-    expect(remove).not.toBeNull();
-    remove.click();
-    expect(conn.el.querySelector<HTMLElement>(".structured-attachments")!.hidden).toBe(true);
-    conn.dispose();
-  });
-
   it("renders every row from the initial snapshot", () => {
     const ws = new FakeSocket();
     const conn = mount({ sockets: [ws] });

web/src/structured.ts

@@ -10,7 +10,6 @@ import {
   cancelStructuredTurn,
   resolveStructuredApproval,
   sendStructuredPrompt,
-  uploadStructuredFile,
   setStructuredConfig,
   structuredWsUrl,
 } from "./api.js";
@@ -91,12 +90,7 @@ export function createStructuredConnection(
           <span class="structured-activity-text">Thinking</span>
         </div>
         <form class="structured-composer">
-          <button type="button" class="btn btn-ghost btn-icon structured-attach" aria-label="Attach files" title="Attach files (up to 20 MiB each)">
-            <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" aria-hidden="true"><path d="m8 12 7-7a3 3 0 0 1 4 4L9 19a5 5 0 0 1-7-7L12 2M5 14l9-9"/></svg>
-          </button>
-          <input class="structured-file-input" type="file" multiple hidden>
           <div class="structured-input-wrap">
-            <div class="structured-attachments" aria-label="Attachments" aria-live="polite" hidden></div>
             <div id="structured-command-menu-${sessionId}" class="structured-command-menu"
               role="listbox" hidden></div>
             <textarea class="structured-input" rows="1" placeholder="Reply, or / for commands…"
@@ -134,79 +128,6 @@ export function createStructuredConnection(
   const input = el.querySelector(".structured-input") as HTMLTextAreaElement;
   const sendBtn = el.querySelector(".structured-send") as HTMLButtonElement;
   const cancelBtn = el.querySelector(".structured-cancel") as HTMLButtonElement;
-  const attachBtn = el.querySelector(".structured-attach") as HTMLButtonElement;
-  const fileInput = el.querySelector(".structured-file-input") as HTMLInputElement;
-  const attachmentEl = el.querySelector(".structured-attachments") as HTMLDivElement;
-  type Attachment = { file: File; path?: string };
-  let attachments: Attachment[] = [];
-  let uploading = false;
-  let pasteCount = 0;
-
-  function renderAttachments(): void {
-    attachmentEl.replaceChildren();
-    attachmentEl.hidden = attachments.length === 0;
-    for (const attachment of attachments) {
-      const chip = document.createElement("span");
-      chip.className = "structured-attachment";
-      const label = document.createElement("span");
-      label.textContent = attachment.file.name;
-      label.title = `${attachment.file.name} (${attachment.file.size.toLocaleString()} bytes)`;
-      const remove = document.createElement("button");
-      remove.type = "button";
-      remove.textContent = "×";
-      remove.setAttribute("aria-label", `Remove ${attachment.file.name}`);
-      remove.disabled = input.disabled;
-      remove.addEventListener("click", () => {
-        attachments = attachments.filter((item) => item !== attachment);
-        renderAttachments();
-      });
-      chip.append(label, remove);
-      attachmentEl.append(chip);
-    }
-  }
-
-  function addFiles(files: File[]): void {
-    if (input.disabled || disposed) return;
-    for (const file of files) {
-      if (file.size > 20 * 1024 * 1024) {
-        showError(`${file.name} exceeds 20 MiB. Choose a smaller file.`);
-      } else if (attachments.length >= 10) {
-        showError("Attach up to 10 files per message.");
-      } else {
-        attachments.push({ file });
-      }
-    }
-    renderAttachments();
-  }
-  attachBtn.addEventListener("click", () => fileInput.click());
-  fileInput.addEventListener("change", () => {
-    addFiles(Array.from(fileInput.files ?? []));
-    fileInput.value = "";
-  });
-  composerForm.addEventListener("dragover", (event) => {
-    if (event.dataTransfer?.types.includes("Files")) event.preventDefault();
-  });
-  composerForm.addEventListener("drop", (event) => {
-    if (!event.dataTransfer?.files.length) return;
-    event.preventDefault();
-    addFiles(Array.from(event.dataTransfer.files));
-  });
-  input.addEventListener("paste", (event) => {
-    const clipboard = event.clipboardData;
-    if (!clipboard || input.disabled) return;
-    if (clipboard.files.length) {
-      event.preventDefault();
-      addFiles(Array.from(clipboard.files));
-      return;
-    }
-    const text = clipboard.getData("text/plain");
-    if (text.length < 4000 && text.split("\n").length < 40) return;
-    if (attachments.length >= 10 || new Blob([text]).size > 20 * 1024 * 1024) return;
-    event.preventDefault();
-    addFiles([new File([text], `pasted-${++pasteCount}.txt`, { type: "text/plain" })]);
-    input.setRangeText("", input.selectionStart, input.selectionEnd, "end");
-    autoResize();
-  });
 
   disconnectBtn.addEventListener("click", () => opts.onRequestClose?.(sessionId));
   // Mobile-only (CSS hides it on desktop, where the sidebar is always in
@@ -606,12 +527,9 @@ export function createStructuredConnection(
   }
 
   function renderComposerState(): void {
-    const active = uploading || state.turn.responding || state.turn.thinking || awaitingBeginGeneration !== null;
+    const active = state.turn.responding || state.turn.thinking || awaitingBeginGeneration !== null;
     const projectedActive = state.turn.responding || state.turn.thinking;
     input.disabled = active;
-    attachBtn.disabled = active;
-    fileInput.disabled = active;
-    renderAttachments();
     sendBtn.disabled = active;
     sendBtn.hidden = projectedActive;
     cancelBtn.hidden = !projectedActive;
@@ -879,9 +797,7 @@ export function createStructuredConnection(
   composerForm.addEventListener("submit", (e) => {
     e.preventDefault();
     const text = input.value;
-    if ((!text.trim() && attachments.length === 0) || input.disabled) return;
+    if (!text.trim() || input.disabled) return;
-    const submittedAttachments = attachments;
-    uploading = submittedAttachments.length > 0;
     const generation = ++submissionGeneration;
     const submissionSocketGeneration = socketGeneration;
     awaitingBeginGeneration = generation;
@@ -891,26 +807,13 @@ export function createStructuredConnection(
     autoResize();
     clearError();
     renderComposerState();
-    const send = async () => {
+    sendStructuredPrompt(sessionId, text).then(
-      for (const attachment of submittedAttachments) {
-        if (disposed) return;
-        if (!attachment.path) attachment.path = (await uploadStructuredFile(sessionId, attachment.file)).path;
-      }
-      if (disposed) return;
-      const references = submittedAttachments.map(({ file, path }) =>
-        `Attached file ${JSON.stringify(file.name)}: ${JSON.stringify(path)}`);
-      await sendStructuredPrompt(sessionId, [text, ...references].filter(Boolean).join("\n\n"));
-    };
-    void send().then(
       () => {
-        if (disposed || generation !== submissionGeneration) return;
+        if (
-        uploading = false;
+          disposed
-        if (attachments === submittedAttachments) {
+          || generation !== submissionGeneration
-          attachments = [];
+          || awaitingBeginGeneration !== generation
-          renderAttachments();
+        ) return;
-        }
-        renderComposerState();
-        if (awaitingBeginGeneration !== generation) return;
         const acceptanceSocketGeneration = socketGeneration;
         acceptedSubmission = { generation, socketGeneration: acceptanceSocketGeneration };
         // A replacement socket may have captured idle before the POST claimed
@@ -918,7 +821,6 @@ export function createStructuredConnection(
         if (acceptanceSocketGeneration > submissionSocketGeneration) reconnectForReconciliation();
       },
       (e: unknown) => {
-        uploading = false;
         if (disposed || generation !== submissionGeneration) return;
         if (awaitingBeginGeneration === generation) awaitingBeginGeneration = null;
         if (input.value === "") {

web/src/structuredRender.ts

@@ -594,7 +594,14 @@ export function buildToolGroup(
   glyph.setAttribute("aria-hidden", "true");
   const title = el("span", "st-tool-group-title");
   title.textContent = `${rows.length} tool calls`;
-  head.append(glyph, title);
+  const names = el("span", "st-tool-group-names");
+  names.textContent = rows
+    .map((row) => {
+      const tool = (row.data ?? {}) as AcpToolCallLike;
+      return splitToolTitle(tool.title, tool.name, tool.kind).label;
+    })
+    .join(" · ");
+  head.append(glyph, title, names);
 
   const body = el("div", "st-tool-group-body st-disclosure");
   const bodyClip = el("div", "st-disclosure-clip");

web/src/styles.css

@@ -2306,9 +2306,6 @@ input.leaf-rename:focus {
   display: flex;
   flex-direction: column;
   min-width: 0;
-  max-width: 820px;
-  margin-inline: auto;
-  width: 100%;
 }
 
 .structured-activity {
@@ -2831,12 +2828,12 @@ input.leaf-rename:focus {
   border: 1px solid var(--border);
   border-radius: var(--r-2);
   background: color-mix(in oklab, var(--surface-2) 55%, transparent);
-  padding: var(--sp-1) var(--sp-2);
+  padding: var(--sp-2) var(--sp-3);
   transition: background var(--dur-fast) var(--ease-out);
 }
 
 .st-tool-group:hover {
-  background: color-mix(in oklab, var(--surface-2) 70%, transparent);
+  background: var(--surface-2);
 }
 
 .st-tool-group-head {
@@ -2873,6 +2870,15 @@ input.leaf-rename:focus {
   font-weight: 500;
 }
 
+.st-tool-group-names {
+  min-width: 0;
+  overflow: hidden;
+  color: var(--muted);
+  text-align: left;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
 .st-tool-group-body {
   padding-top: 0;
 }
@@ -2880,22 +2886,11 @@ input.leaf-rename:focus {
 .st-tool-group-body .st-disclosure-inner {
   display: flex;
   flex-direction: column;
-  padding-top: var(--sp-1);
+  padding-top: var(--sp-2);
 }
 
 .st-tool-group-body .st-disclosure-inner > .st-row-tool {
-  padding: 0;
+  padding: var(--sp-1) 0;
-}
-
-/* inside a group, tool cards lose their border and background —
-   the group container already provides the visual boundary. */
-.st-tool-group-body .st-tool {
-  border: 0;
-}
-
-.st-tool-group-body .st-tool-head {
-  padding: var(--sp-1) var(--sp-2);
-  border-radius: var(--r-1);
 }
 
 .st-tool-group-body[hidden] {
@@ -3067,24 +3062,31 @@ input.leaf-rename:focus {
 }
 
 /* The composer is a sibling of the scrolling transcript, not part of it: it
-   stays reachable at the pane edge without changing transcript scroll math.
+   stays reachable at the pane edge without changing transcript scroll math. */
-   It is a flush band at the foot of the pane rather than a floating card: its
-   own `--surface` fill is what separates it from the transcript, over a
-   hairline that doubles as the focus indicator. Inner metrics line the draft
-   up with the transcript's own 12px gutter. */
 .structured-composer {
   flex: 0 0 auto;
-  padding: var(--sp-1) var(--sp-1) max(var(--sp-1), env(safe-area-inset-bottom));
+  margin: var(--sp-2) var(--sp-3) max(var(--sp-2), env(safe-area-inset-bottom));
-  border-top: 1px solid var(--border);
+  padding: var(--sp-1);
+  border: 1px solid var(--border-strong);
+  border-radius: var(--r-3);
   background: var(--surface);
   display: flex;
   align-items: flex-end;
   gap: var(--sp-1);
-  transition: border-color var(--dur-fast) var(--ease-out);
+  box-shadow:
+    inset 0 1px 0 color-mix(in oklab, var(--ink) 6%, transparent),
+    var(--shadow-1);
+  transition:
+    border-color var(--dur-fast) var(--ease-out),
+    box-shadow var(--dur-fast) var(--ease-out);
 }
 
 .structured-composer:focus-within {
-  border-top-color: var(--accent);
+  border-color: var(--accent);
+  box-shadow:
+    inset 0 1px 0 color-mix(in oklab, var(--ink) 8%, transparent),
+    0 0 0 3px var(--accent-tint),
+    var(--shadow-1);
 }
 
 .structured-input-wrap {
@@ -3093,45 +3095,6 @@ input.leaf-rename:focus {
   min-width: 0;
 }
 
-.structured-attachments {
-  display: flex;
-  flex-wrap: wrap;
-  gap: var(--sp-1);
-  padding: var(--sp-1);
-}
-
-.structured-attachments[hidden] { display: none; }
-
-.structured-attachment {
-  display: inline-flex;
-  align-items: center;
-  min-width: 0;
-  max-width: 100%;
-  padding-left: var(--sp-2);
-  background: var(--surface-2);
-  border: 1px solid var(--border);
-  border-radius: var(--r-1);
-  font-size: var(--fs-11);
-}
-
-.structured-attachment > span {
-  overflow: hidden;
-  text-overflow: ellipsis;
-  white-space: nowrap;
-}
-
-.structured-attachment button {
-  flex-shrink: 0;
-  min-width: var(--tap);
-  min-height: var(--tap);
-  border: 0;
-  background: transparent;
-  color: var(--muted);
-}
-
-.structured-attachment button:hover { color: var(--ink); }
-.structured-attachment button:disabled { opacity: 0.5; }
-
 .structured-input {
   display: block;
   width: 100%;
@@ -3149,10 +3112,6 @@ input.leaf-rename:focus {
   line-height: 20px;
 }
 
-.structured-input:focus-visible {
-  outline: none;
-}
-
 .structured-composer .structured-send,
 .structured-composer .structured-cancel {
   height: 40px;
@@ -3210,29 +3169,17 @@ input.leaf-rename:focus {
 }
 
 @media (max-width: 520px) {
-  /* One row cannot hold a draft plus three controls at phone width — the
-     draft gets a line of its own and the controls drop below it. */
   .structured-composer {
-    flex-wrap: wrap;
+    margin: var(--sp-1) 0 0;
-    justify-content: flex-end;
+    padding-bottom: calc(var(--sp-1) + env(safe-area-inset-bottom, 0px));
-    padding-left: var(--sp-2);
+    border-right: 0;
-    padding-right: var(--sp-2);
+    border-bottom: 0;
-  }
+    border-left: 0;
-
+    border-radius: var(--r-2) var(--r-2) 0 0;
-  /* `order` keeps the draft on the first line: without it the attach button,
-     which precedes it in the DOM, wraps onto a line of its own. */
-  .structured-input-wrap {
-    flex: 1 1 100%;
-    order: -1;
-  }
-
-  .structured-composer .structured-config {
-    margin-right: auto;
   }
 
   .structured-config-menu {
-    left: 0;
+    right: calc(-1 * (var(--control-h) + var(--sp-2)));
-    right: auto;
   }
 }
 
@@ -3446,9 +3393,14 @@ input.leaf-rename:focus {
     overflow-y: visible;
   }
 
+  /* Rides the bottom of the scroll box: reachable at any scroll position, and
+     `margin-top: auto` keeps it at the screen's foot when the form is short. */
   .spawn-modal .form-actions {
+    position: sticky;
+    bottom: 0;
     margin-top: auto;
-    padding-bottom: calc(var(--sp-2) + env(safe-area-inset-bottom, 0px));
+    padding: var(--sp-2) 0 calc(var(--sp-2) + env(safe-area-inset-bottom, 0px));
+    background: var(--surface);
     box-shadow: 0 -8px 12px -8px oklch(0 0 0 / 0.5);
   }
 
@@ -3530,16 +3482,20 @@ input.leaf-rename:focus {
   flex: 0 0 auto;
 }
 
-.advanced {
+.worktree {
+  border: 1px solid var(--border);
+  border-radius: var(--r-2);
+  padding: 0 var(--sp-3);
+  margin: 0;
   display: flex;
   flex-direction: column;
+  background: color-mix(in oklab, var(--surface-2) 50%, transparent);
 }
 
-.advanced .wt-toggle {
+.worktree .wt-toggle {
-  border-top: 1px solid var(--border);
+  margin: 0 calc(var(--sp-3) * -1);
-  border-radius: 0;
+  padding-left: var(--sp-3);
-  padding-top: var(--sp-2);
+  width: calc(100% + var(--sp-3) * 2);
-  padding-bottom: var(--sp-2);
 }
 
 .wt-summary {
@@ -3551,27 +3507,13 @@ input.leaf-rename:focus {
   display: flex;
   flex-direction: column;
   gap: var(--sp-3);
-  padding: var(--sp-2) 0 var(--sp-1);
+  padding-bottom: var(--sp-3);
 }
 
 .wt-collapsible[hidden] {
   display: none;
 }
 
-/* Worktree sub-group: left accent border when expanded, visually nested. */
-.adv-group {
-  display: flex;
-  flex-direction: column;
-  gap: var(--sp-3);
-  padding-left: var(--sp-3);
-  border-left: 2px solid var(--border);
-  margin-top: var(--sp-1);
-}
-
-.adv-group:has(input[name="worktree_enabled"]:checked) {
-  border-left-color: var(--accent);
-}
-
 .form-error {
   color: var(--danger);
   margin: 0;
@@ -3889,11 +3831,6 @@ input.leaf-rename:focus {
   gap: var(--sp-2);
   justify-content: flex-end;
   margin-top: var(--sp-2);
-  position: sticky;
-  bottom: 0;
-  padding: var(--sp-2) 0;
-  background: var(--surface);
-  z-index: 1;
 }
 
 .reroll {