fix(maestro): assert on the git shim log, not a wall-clock budget

a_session_without_a_worktree_costs_no_probe waited up to 5s for the
watcher pass to run, using that wait's timeout panic as an implicit
proxy for "no probe happened". Under a loaded full-workspace run the
watcher task can be scheduled well past 5s, so the test flaked.

Poll the shim log directly for A's probe instead of a derived snapshot
state, and use the wait only as a 30s hang guard. The actual property
- B was never probed - is asserted unconditionally on the log content,
independent of timing.

Fixes #173.

.gitea/workflows/ci.yml

@@ -9,7 +9,7 @@ on:
 
 concurrency:
   group: ci-${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: true
+  cancel-in-progress: ${{ github.ref != 'refs/heads/main' }}
 
 env:
   CARGO_TERM_COLOR: always

.gitignore

@@ -15,6 +15,3 @@ worktrees/
 
 # `nix run .#dev` scratch state (tmux socket)
 /.dev/
-
-# Per-machine Claude Code tool permissions
-.claude/settings.local.json

CLAUDE.md

@@ -14,6 +14,7 @@ maestro daemon            tmux wrapper + session API + SPA on 127.0.0.1:7070
   ├── DELETE   /api/sessions/:id    kill
   ├── POST     /api/sessions/:id/input  type text into a session
   ├── POST     /api/sessions/:id/prompt an agent reports its first prompt (#131)
+  ├── POST     /api/sessions/:id/resume respawn a dormant session, same id (#166)
   ├── GET      /api/info            hostname, version, home dir, spawn presets
   ├── GET      /api/dirs            directory listing (spawn autocomplete)
   ├── GET      /api/recent-dirs     spawn history
@@ -92,12 +93,6 @@ clients — how it opens, the sigils, the key model, the match-and-rank algorith
 the two matchers must agree on, and the fixture table they are tested against.
 Read it before changing either bar or either matcher.
 
-`docs/STRUCTURED-VIEW.md` is the contract for a structured session (an agent
-run as a daemon child over ACP instead of in a tmux pane) — the eight
-transcript row kinds, the two projections and their cursor/replay semantics,
-the handshake and declined capabilities, and the approval nonce rules. Read
-it before changing anything that renders a structured session.
-
 `nix run .#dev` (or `just dev`) brings up the whole local stack under
 process-compose: a debug daemon on 127.0.0.1:7071, then Vite on :5173 once the
 daemon answers `/api/info`. The SPA proxies `/api/*` back to the daemon, so only

Cargo.toml

@@ -10,7 +10,6 @@ repository = "https://git.naps.pt/naps62/maestro"
 publish = false
 
 [workspace.dependencies]
-agent-client-protocol = { version = "2.1", features = ["unstable_tool_call_name"] }
 axum = { version = "0.7", features = ["ws"] }
 chrono = { version = "0.4", default-features = false, features = ["clock", "serde"] }
 clap = { version = "4.5", features = ["derive", "env"] }
@@ -18,7 +17,6 @@ crossterm = { version = "0.28", features = ["event-stream"] }
 dirs = "5"
 futures-util = { version = "0.3", default-features = false, features = ["sink", "std"] }
 libc = "0.2"
-maestro-acp = { path = "crates/maestro-acp" }
 maestro-config = { path = "crates/maestro-config" }
 # `default-features = false` so each consumer opts into `haiku-autoname`
 # through its own feature of the same name (#131); a workspace entry that
@@ -40,11 +38,9 @@ tempfile = "3"
 thiserror = "1"
 tokio = { version = "1", features = ["macros", "rt-multi-thread", "sync", "time", "net", "io-util", "fs", "signal", "process"] }
 tokio-tungstenite = "0.21"
-tokio-util = { version = "0.7", features = ["compat"] }
 toml = "0.8"
 tracing = "0.1"
 tracing-subscriber = { version = "0.3", features = ["env-filter"] }
-unicode-width = "0.1"
 uuid = { version = "1", features = ["v4", "serde"] }
 ratatui = "0.28"
 vt100 = "0.15"

crates/maestro-acp/Cargo.toml

@@ -1,21 +0,0 @@
-[package]
-name = "maestro-acp"
-version.workspace = true
-edition.workspace = true
-license.workspace = true
-repository.workspace = true
-publish.workspace = true
-description = "ACP client role: one provider adapter child per structured session"
-
-[dependencies]
-agent-client-protocol.workspace = true
-libc.workspace = true
-serde.workspace = true
-serde_json.workspace = true
-thiserror.workspace = true
-tokio.workspace = true
-tokio-util.workspace = true
-tracing.workspace = true
-
-[dev-dependencies]
-tempfile.workspace = true

crates/maestro-acp/tests/fake_acp_agent.py

@@ -1,262 +0,0 @@
-#!/usr/bin/env python3
-"""A deterministic stand-in for `claude-code-acp` (#134).
-
-Speaks just enough JSON-RPC over stdio for the daemon's handshake:
-answers `initialize` and `session/new`, logs every method it receives, and
-exits on SIGTERM. Tests point `PATH` at a directory holding this file under
-the adapter's name, so the real adapter (which needs Claude auth and is
-slow) never runs in the deterministic suite.
-
-Environment knobs, all optional:
-
-  FAKE_ACP_LOG            append one line per event to this file:
-                            start pid=<pid> cwd=<cwd>
-                            env <NAME>=<value>       (for FAKE_ACP_ECHO_ENV)
-                            caps <json of clientCapabilities>
-                            recv <method>
-                            signal SIGTERM
-  FAKE_ACP_ECHO_ENV       name of one env var to log at start
-  FAKE_ACP_INIT_FAIL=1    answer `initialize` with a JSON-RPC error
-  FAKE_ACP_DELAY_SESSION_NEW_MS=n  wait n milliseconds before answering
-                             `session/new`
-  FAKE_ACP_SESSION_NEW_GATE=path  wait for `path` to exist before answering
-                             `session/new`
-  FAKE_ACP_EXIT_AFTER_NEW=1  exit 0 right after answering `session/new`
-  FAKE_ACP_EXIT_ON_CANCEL=1  exit 0 on `session/cancel` (default: keep running
-                             so the SIGTERM path is exercised)
-  FAKE_ACP_IGNORE_EOF=1      keep running after stdin closes, until signalled
-  FAKE_ACP_EMIT_ON_CANCEL=1  emit a final notification before handling cancel
-  FAKE_ACP_CANCEL_SETTLES=1  complete the outstanding prompt on cancel
-  FAKE_ACP_NO_LOAD=1      advertise `loadSession: false`
-  FAKE_ACP_LOAD_REPLAY=n  on `session/load`, replay n `agent_message_chunk`
-                            notifications ("replayed <i>") before answering,
-                            the way a real agent streams history back
-  FAKE_ACP_LOAD_FAIL=1    answer `session/load` with a JSON-RPC error
-  FAKE_ACP_DELAY_PROMPT_MS=n  wait before answering `session/prompt`
-  FAKE_ACP_PROMPT_FAIL=1  answer every `session/prompt` with a JSON-RPC error
-  FAKE_ACP_PROMPT_FAIL_ONCE=1  answer only the first `session/prompt` with a
-                             JSON-RPC error
-  FAKE_ACP_SETTINGS=1      advertise legacy model/mode and modern effort options
-  FAKE_ACP_PERMISSION_AFTER_CANCEL=1  defer the first prompt's permission
-                             callback until a later prompt
-
-Signals: SIGUSR1 emits one `agent_message_chunk` notification ("tick <n>",
-counting from 1) and logs `emit tick <n>`, so a test can make the agent
-speak on demand (#135).
-"""
-import json
-import os
-import signal
-import sys
-import time
-
-LOG = os.environ.get("FAKE_ACP_LOG")
-
-
-def log(line):
-    if not LOG:
-        return
-    with open(LOG, "a") as f:
-        f.write(line + "\n")
-        f.flush()
-
-
-def send(obj):
-    sys.stdout.write(json.dumps(obj) + "\n")
-    sys.stdout.flush()
-
-
-def on_sigterm(_signum, _frame):
-    log("signal SIGTERM")
-    sys.exit(0)
-
-
-signal.signal(signal.SIGTERM, on_sigterm)
-
-session_id = f"fake-{os.getpid()}"
-ticks = 0
-prompt_failures = 0
-pending_prompt_id = None
-pending_permission_id = None
-delayed_permission = False
-current_model = "opus"
-current_mode = "default"
-current_effort = "high"
-
-
-def settings_response(include_session=False):
-    result = {}
-    if include_session:
-        result["sessionId"] = session_id
-    if os.environ.get("FAKE_ACP_SETTINGS") == "1":
-        result.update({
-            "models": {
-                "currentModelId": current_model,
-                "availableModels": [
-                    {"modelId": "opus", "name": "Opus"},
-                    {"modelId": "sonnet", "name": "Sonnet"},
-                ],
-            },
-            "modes": {
-                "currentModeId": current_mode,
-                "availableModes": [
-                    {"id": "default", "name": "Default"},
-                    {"id": "plan", "name": "Plan"},
-                ],
-            },
-            "configOptions": [{
-                "id": "effort", "name": "Effort", "category": "thought_level",
-                "type": "select", "currentValue": current_effort,
-                "options": [
-                    {"value": "low", "name": "Low"},
-                    {"value": "high", "name": "High"},
-                ],
-            }],
-        })
-    return result
-
-
-def chunk(text):
-    return {"jsonrpc": "2.0", "method": "session/update", "params": {
-        "sessionId": session_id,
-        "update": {"sessionUpdate": "agent_message_chunk",
-                   "content": {"type": "text", "text": text}},
-    }}
-
-
-def on_sigusr1(_signum, _frame):
-    global ticks
-    ticks += 1
-    send(chunk(f"tick {ticks}"))
-    log(f"emit tick {ticks}")
-
-
-signal.signal(signal.SIGUSR1, on_sigusr1)
-
-log(f"start pid={os.getpid()} cwd={os.getcwd()}")
-echo = os.environ.get("FAKE_ACP_ECHO_ENV")
-if echo:
-    log(f"env {echo}={os.environ.get(echo, '')}")
-
-for raw in sys.stdin:
-    raw = raw.strip()
-    if not raw:
-        continue
-    msg = json.loads(raw)
-    method = msg.get("method")
-    if method is None:
-        # A response to something we sent; nothing to do.
-        if msg.get("id") == pending_permission_id:
-            log("permission response " + json.dumps(msg.get("result"), sort_keys=True))
-            send({"jsonrpc": "2.0", "id": pending_prompt_id,
-                  "result": {"stopReason": "end_turn"}})
-            pending_prompt_id = None
-            pending_permission_id = None
-        continue
-    log(f"recv {method}")
-    rid = msg.get("id")
-    params = msg.get("params") or {}
-
-    if method == "initialize":
-        log("caps " + json.dumps(params.get("clientCapabilities", {}), sort_keys=True))
-        if os.environ.get("FAKE_ACP_INIT_FAIL") == "1":
-            send({"jsonrpc": "2.0", "id": rid,
-                  "error": {"code": -32000, "message": "fake init failure"}})
-            continue
-        send({"jsonrpc": "2.0", "id": rid, "result": {
-            "protocolVersion": params.get("protocolVersion", 1),
-            "agentCapabilities": {
-                "loadSession": os.environ.get("FAKE_ACP_NO_LOAD") != "1"},
-            "agentInfo": {"name": "fake-acp-agent", "version": "0.0.0"},
-            "authMethods": [],
-        }})
-    elif method == "session/new":
-        gate = os.environ.get("FAKE_ACP_SESSION_NEW_GATE")
-        while gate and not os.path.exists(gate):
-            time.sleep(0.01)
-        time.sleep(int(os.environ.get("FAKE_ACP_DELAY_SESSION_NEW_MS", "0")) / 1000)
-        send({"jsonrpc": "2.0", "id": rid, "result": settings_response(True)})
-        send(chunk("hello from fake"))
-        if os.environ.get("FAKE_ACP_EXIT_AFTER_NEW") == "1":
-            sys.exit(0)
-    elif method == "session/load":
-        session_id = params.get("sessionId")
-        log(f"recv session/load sessionId={session_id}")
-        if os.environ.get("FAKE_ACP_LOAD_FAIL") == "1":
-            send({"jsonrpc": "2.0", "id": rid,
-                  "error": {"code": -32000, "message": "fake load failure"}})
-            continue
-        for i in range(int(os.environ.get("FAKE_ACP_LOAD_REPLAY", "0"))):
-            send(chunk(f"replayed {i + 1}"))
-        send({"jsonrpc": "2.0", "id": rid, "result": settings_response()})
-        send(chunk("hello after load"))
-    elif method == "session/set_model":
-        current_model = params.get("modelId")
-        send({"jsonrpc": "2.0", "id": rid, "result": {}})
-    elif method == "session/set_mode":
-        current_mode = params.get("modeId")
-        send({"jsonrpc": "2.0", "id": rid, "result": {}})
-    elif method == "session/set_config_option":
-        current_effort = params.get("value")
-        send({"jsonrpc": "2.0", "id": rid, "result": {
-            "configOptions": settings_response()["configOptions"]}})
-    elif method == "session/cancel":
-        if os.environ.get("FAKE_ACP_EMIT_ON_CANCEL") == "1":
-            send(chunk("final on cancel"))
-        if (os.environ.get("FAKE_ACP_CANCEL_SETTLES") == "1"
-                and pending_prompt_id is not None):
-            send({"jsonrpc": "2.0", "id": pending_prompt_id,
-                  "result": {"stopReason": "cancelled"}})
-            pending_prompt_id = None
-            pending_permission_id = None
-        if os.environ.get("FAKE_ACP_EXIT_ON_CANCEL") == "1":
-            sys.exit(0)
-    elif method == "session/prompt":
-        if os.environ.get("FAKE_ACP_PERMISSION_AFTER_CANCEL") == "1":
-            if pending_prompt_id is None:
-                pending_prompt_id = rid
-                delayed_permission = True
-                continue
-            if delayed_permission:
-                delayed_permission = False
-                pending_permission_id = "permission-1"
-                send({"jsonrpc": "2.0", "id": pending_permission_id,
-                      "method": "session/request_permission", "params": {
-                          "sessionId": session_id,
-                          "toolCall": {"toolCallId": "tool-1", "fields": {}},
-                          "options": [
-                              {"optionId": "once", "name": "Allow once", "kind": "allow_once"},
-                              {"optionId": "deny", "name": "Deny", "kind": "reject_once"}
-                          ]
-                      }})
-                continue
-        if os.environ.get("FAKE_ACP_REQUEST_PERMISSION") == "1":
-            pending_prompt_id = rid
-            pending_permission_id = "permission-1"
-            send({"jsonrpc": "2.0", "id": pending_permission_id,
-                  "method": "session/request_permission", "params": {
-                      "sessionId": session_id,
-                      "toolCall": {"toolCallId": "tool-1", "fields": {}},
-                      "options": [
-                          {"optionId": "once", "name": "Allow once", "kind": "allow_once"},
-                          {"optionId": "session", "name": "Allow session", "kind": "allow_always"},
-                          {"optionId": "deny", "name": "Deny", "kind": "reject_once"}
-                      ]
-                  }})
-            continue
-        time.sleep(int(os.environ.get("FAKE_ACP_DELAY_PROMPT_MS", "0")) / 1000)
-        fail_once = os.environ.get("FAKE_ACP_PROMPT_FAIL_ONCE") == "1"
-        if os.environ.get("FAKE_ACP_PROMPT_FAIL") == "1" or (fail_once and prompt_failures == 0):
-            prompt_failures += 1
-            send({"jsonrpc": "2.0", "id": rid,
-                  "error": {"code": -32000, "message": "fake prompt failure"}})
-        else:
-            send({"jsonrpc": "2.0", "id": rid,
-                  "result": {"stopReason": "end_turn"}})
-    elif rid is not None:
-        send({"jsonrpc": "2.0", "id": rid,
-              "error": {"code": -32601, "message": f"method not found: {method}"}})
-
-if os.environ.get("FAKE_ACP_IGNORE_EOF") == "1":
-    while True:
-        signal.pause()

crates/maestro-acp/tests/spawn.rs

@@ -1,505 +0,0 @@
-//! `maestro-acp` against the fake adapter in `tests/fake_acp_agent.py`, plus
-//! ignored smoke tests against each maintained adapter.
-
-use std::collections::HashMap;
-use std::path::{Path, PathBuf};
-use std::time::{Duration, Instant};
-
-use maestro_acp::schema::{ContentBlock, SessionUpdate};
-use maestro_acp::{AcpAdapter, AcpError, SpawnConfig, ADAPTER_BIN, INSTALL_COMMAND};
-use tempfile::TempDir;
-
-fn fake_agent() -> PathBuf {
-    Path::new(env!("CARGO_MANIFEST_DIR")).join("tests/fake_acp_agent.py")
-}
-
-/// A temp `bin/` holding the fake agent under the adapter's name, plus a
-/// log file the agent appends to. `PATH` for the spawn is just that dir.
-struct Fake {
-    dir: TempDir,
-}
-
-impl Fake {
-    fn new() -> Self {
-        let dir = TempDir::new().unwrap();
-        let bin = dir.path().join("bin");
-        std::fs::create_dir_all(&bin).unwrap();
-        std::fs::copy(fake_agent(), bin.join(ADAPTER_BIN)).unwrap();
-        std::fs::copy(fake_agent(), bin.join(AcpAdapter::Codex.binary())).unwrap();
-        Self { dir }
-    }
-
-    fn log_path(&self) -> PathBuf {
-        self.dir.path().join("agent.log")
-    }
-
-    fn log(&self) -> String {
-        std::fs::read_to_string(self.log_path()).unwrap_or_default()
-    }
-
-    /// The fake's `bin/` first, so it shadows any real adapter, then the
-    /// process `PATH` so the script's `python3` still resolves.
-    fn env(&self) -> HashMap<String, String> {
-        let path = format!(
-            "{}:{}",
-            self.dir.path().join("bin").display(),
-            std::env::var("PATH").unwrap_or_default()
-        );
-        HashMap::from([
-            ("PATH".to_string(), path),
-            (
-                "FAKE_ACP_LOG".to_string(),
-                self.log_path().to_string_lossy().into_owned(),
-            ),
-        ])
-    }
-
-    fn config(&self, cwd: &Path) -> SpawnConfig {
-        let mut config = SpawnConfig::new(cwd, self.env());
-        config.handshake_timeout = Duration::from_secs(10);
-        config
-    }
-
-    async fn wait_for_log(&self, needle: &str) {
-        let deadline = Instant::now() + Duration::from_secs(5);
-        while Instant::now() < deadline {
-            if self.log().contains(needle) {
-                return;
-            }
-            tokio::time::sleep(Duration::from_millis(20)).await;
-        }
-        panic!("log never contained {needle:?}:\n{}", self.log());
-    }
-
-    fn pid(&self) -> u32 {
-        self.log()
-            .lines()
-            .find_map(|line| line.strip_prefix("start pid="))
-            .and_then(|rest| rest.split(' ').next())
-            .and_then(|pid| pid.parse().ok())
-            .expect("pid in log")
-    }
-
-    async fn wait_for_exit(&self) {
-        let pid = self.pid();
-        let deadline = Instant::now() + Duration::from_secs(5);
-        while pid_alive(pid) && Instant::now() < deadline {
-            tokio::time::sleep(Duration::from_millis(20)).await;
-        }
-        assert!(!pid_alive(pid), "child {pid} still alive");
-    }
-}
-
-fn pid_alive(pid: u32) -> bool {
-    Path::new(&format!("/proc/{pid}")).exists()
-        && std::fs::read_to_string(format!("/proc/{pid}/stat"))
-            .map(|s| !s.contains(") Z "))
-            .unwrap_or(false)
-}
-
-#[tokio::test]
-async fn spawn_runs_adapter_in_cwd_with_env_and_restrictive_caps() {
-    let fake = Fake::new();
-    let cwd = TempDir::new().unwrap();
-    let mut config = fake.config(cwd.path());
-    config
-        .env
-        .insert("FAKE_ACP_ECHO_ENV".into(), "MAESTRO_SESSION_ID".into());
-    config
-        .env
-        .insert("MAESTRO_SESSION_ID".into(), "sess-123".into());
-
-    let session = maestro_acp::spawn(config).await.expect("spawn");
-    assert!(session.session_id().starts_with("fake-"));
-    assert!(pid_alive(session.pid()));
-
-    let log = fake.log();
-    let cwd_canon = cwd.path().canonicalize().unwrap();
-    assert!(
-        log.contains(&format!("cwd={}", cwd_canon.display())),
-        "child cwd missing from log:\n{log}"
-    );
-    assert!(log.contains("env MAESTRO_SESSION_ID=sess-123"), "{log}");
-    assert!(log.contains("recv initialize"), "{log}");
-    assert!(log.contains("recv session/new"), "{log}");
-    let caps = log
-        .lines()
-        .find_map(|l| l.strip_prefix("caps "))
-        .expect("caps line");
-    let caps: serde_json::Value = serde_json::from_str(caps).unwrap();
-    assert_eq!(caps["fs"]["readTextFile"], false);
-    assert_eq!(caps["fs"]["writeTextFile"], false);
-    assert_eq!(caps["terminal"], false);
-
-    session
-        .terminate(Duration::from_millis(100), Duration::from_secs(2))
-        .await;
-}
-
-#[tokio::test]
-async fn missing_adapter_names_the_install_command() {
-    let empty = TempDir::new().unwrap();
-    let cwd = TempDir::new().unwrap();
-    let env = HashMap::from([(
-        "PATH".to_string(),
-        empty.path().to_string_lossy().into_owned(),
-    )]);
-    let err = maestro_acp::spawn(SpawnConfig::new(cwd.path(), env))
-        .await
-        .expect_err("no adapter on PATH");
-    assert!(matches!(
-        err,
-        AcpError::AdapterMissing {
-            adapter: AcpAdapter::ClaudeCode
-        }
-    ));
-    let msg = err.to_string();
-    assert!(msg.contains(ADAPTER_BIN), "{msg}");
-    assert!(msg.contains(INSTALL_COMMAND), "{msg}");
-}
-
-#[test]
-fn codex_adapter_has_its_own_binary_and_install_guidance() {
-    assert_eq!(AcpAdapter::Codex.binary(), "codex-acp");
-    assert!(AcpAdapter::Codex
-        .install_command()
-        .contains("@agentclientprotocol/codex-acp"));
-}
-
-#[tokio::test]
-async fn spawn_selects_the_codex_adapter() {
-    let fake = Fake::new();
-    let cwd = TempDir::new().unwrap();
-    let session = maestro_acp::spawn(fake.config(cwd.path()).adapter(AcpAdapter::Codex))
-        .await
-        .expect("spawn Codex adapter");
-    assert!(fake.log().contains("recv session/new"));
-    session
-        .terminate(Duration::from_millis(100), Duration::from_secs(2))
-        .await;
-}
-
-#[tokio::test]
-async fn session_updates_reach_the_taken_receiver() {
-    let fake = Fake::new();
-    let cwd = TempDir::new().unwrap();
-    let session = maestro_acp::spawn(fake.config(cwd.path()))
-        .await
-        .expect("spawn");
-
-    let mut updates = session.take_updates().expect("first take");
-    assert!(session.take_updates().is_none(), "handed out once");
-    let first = tokio::time::timeout(Duration::from_secs(5), updates.recv())
-        .await
-        .expect("update within 5s")
-        .expect("channel open");
-    assert_eq!(first.session_id.0.as_ref(), session.session_id());
-    match first.update {
-        SessionUpdate::AgentMessageChunk(chunk) => match chunk.content {
-            ContentBlock::Text(t) => assert_eq!(t.text, "hello from fake"),
-            other => panic!("unexpected content {other:?}"),
-        },
-        other => panic!("unexpected update {other:?}"),
-    }
-
-    session
-        .terminate(Duration::from_millis(100), Duration::from_secs(2))
-        .await;
-}
-
-#[tokio::test]
-async fn advertised_settings_are_normalized_and_mutable() {
-    let fake = Fake::new();
-    let cwd = TempDir::new().unwrap();
-    let mut config = fake.config(cwd.path());
-    config.env.insert("FAKE_ACP_SETTINGS".into(), "1".into());
-    let session = maestro_acp::spawn(config).await.expect("spawn");
-    let mut updates = session.take_updates().expect("updates");
-
-    let initial = loop {
-        let update = tokio::time::timeout(Duration::from_secs(5), updates.recv())
-            .await
-            .expect("settings update")
-            .expect("channel open");
-        if let SessionUpdate::ConfigOptionUpdate(options) = update.update {
-            break options.config_options;
-        }
-    };
-    assert_eq!(initial.len(), 3);
-    assert!(initial
-        .iter()
-        .any(|option| option.id.0.as_ref() == "effort"));
-    assert!(initial
-        .iter()
-        .any(|option| option.id.0.as_ref() == "__maestro_legacy_model"));
-    assert!(initial
-        .iter()
-        .any(|option| option.id.0.as_ref() == "__maestro_legacy_mode"));
-    let model = initial
-        .iter()
-        .find(|option| option.id.0.as_ref() == "__maestro_legacy_model")
-        .expect("legacy model option");
-    let model = serde_json::to_value(model).unwrap();
-    assert_eq!(model["options"][0]["name"], "Opus");
-    assert!(model["options"]
-        .as_array()
-        .unwrap()
-        .iter()
-        .any(|option| option["value"] == "fable"));
-
-    let changed = session
-        .set_config(
-            "__maestro_legacy_model".into(),
-            maestro_acp::schema::SessionConfigOptionValue::value_id("sonnet"),
-        )
-        .expect("queue model change");
-    changed
-        .await
-        .expect("response delivered")
-        .expect("model changed");
-    fake.wait_for_log("recv session/set_model").await;
-
-    session
-        .terminate(Duration::from_millis(100), Duration::from_secs(2))
-        .await;
-}
-
-#[tokio::test]
-async fn terminate_sends_cancel_then_sigterm() {
-    let fake = Fake::new();
-    let cwd = TempDir::new().unwrap();
-    let session = maestro_acp::spawn(fake.config(cwd.path()).adapter(AcpAdapter::Codex))
-        .await
-        .expect("spawn");
-    let pid = session.pid();
-
-    session
-        .terminate(Duration::from_millis(200), Duration::from_secs(2))
-        .await;
-    assert!(session.has_exited());
-    fake.wait_for_log("signal SIGTERM").await;
-
-    let log = fake.log();
-    let cancel = log.find("recv session/cancel").expect("cancel logged");
-    let term = log.find("signal SIGTERM").expect("SIGTERM logged");
-    assert!(cancel < term, "cancel must precede SIGTERM:\n{log}");
-    assert!(!pid_alive(pid), "child {pid} still alive");
-}
-
-#[tokio::test]
-async fn terminate_is_satisfied_by_an_exit_on_cancel() {
-    let fake = Fake::new();
-    let cwd = TempDir::new().unwrap();
-    let mut config = fake.config(cwd.path());
-    config
-        .env
-        .insert("FAKE_ACP_EXIT_ON_CANCEL".into(), "1".into());
-    let session = maestro_acp::spawn(config).await.expect("spawn");
-
-    session
-        .terminate(Duration::from_secs(2), Duration::from_secs(2))
-        .await;
-    assert!(session.has_exited());
-    let log = fake.log();
-    assert!(log.contains("recv session/cancel"), "{log}");
-    assert!(!log.contains("signal SIGTERM"), "cancel was enough:\n{log}");
-}
-
-#[tokio::test]
-async fn handshake_error_fails_the_spawn_and_reaps_the_child() {
-    let fake = Fake::new();
-    let cwd = TempDir::new().unwrap();
-    let mut config = fake.config(cwd.path()).adapter(AcpAdapter::Codex);
-    config.env.insert("FAKE_ACP_INIT_FAIL".into(), "1".into());
-
-    let err = maestro_acp::spawn(config).await.expect_err("init fails");
-    assert!(matches!(err, AcpError::Handshake(_)), "{err}");
-    assert!(err.to_string().contains("fake init failure"), "{err}");
-    // Closing the connection gives the fake EOF on stdin; the SIGTERM that
-    // follows may find it already gone. Either way it must not survive.
-    let pid: u32 = fake
-        .log()
-        .lines()
-        .find_map(|l| l.strip_prefix("start pid="))
-        .and_then(|rest| rest.split(' ').next())
-        .and_then(|p| p.parse().ok())
-        .expect("pid in log");
-    let deadline = Instant::now() + Duration::from_secs(5);
-    while pid_alive(pid) && Instant::now() < deadline {
-        tokio::time::sleep(Duration::from_millis(20)).await;
-    }
-    assert!(!pid_alive(pid), "child {pid} outlived the failed spawn");
-}
-
-#[tokio::test]
-async fn early_exit_is_observed_after_a_successful_handshake() {
-    let fake = Fake::new();
-    let cwd = TempDir::new().unwrap();
-    let mut config = fake.config(cwd.path());
-    config
-        .env
-        .insert("FAKE_ACP_EXIT_AFTER_NEW".into(), "1".into());
-    let session = maestro_acp::spawn(config).await.expect("spawn");
-
-    let status = tokio::time::timeout(Duration::from_secs(5), session.wait())
-        .await
-        .expect("exit within 5s")
-        .expect("status");
-    assert!(status.success(), "{status}");
-    assert!(session.has_exited());
-}
-
-#[tokio::test]
-async fn child_exit_before_handshake_reports_exited_early() {
-    // A "adapter" that dies before answering anything.
-    let dir = TempDir::new().unwrap();
-    let bin = dir.path().join("bin");
-    std::fs::create_dir_all(&bin).unwrap();
-    let script = bin.join(ADAPTER_BIN);
-    std::fs::write(&script, "#!/bin/sh\necho 'not logged in' >&2\nexit 3\n").unwrap();
-    {
-        use std::os::unix::fs::PermissionsExt;
-        std::fs::set_permissions(&script, std::fs::Permissions::from_mode(0o755)).unwrap();
-    }
-    let cwd = TempDir::new().unwrap();
-    let env = HashMap::from([("PATH".to_string(), bin.to_string_lossy().into_owned())]);
-    let mut config = SpawnConfig::new(cwd.path(), env);
-    config.handshake_timeout = Duration::from_secs(10);
-
-    let err = maestro_acp::spawn(config).await.expect_err("child died");
-    match &err {
-        AcpError::ExitedEarly { status, stderr, .. } => {
-            assert!(status.contains('3'), "{status}");
-            assert!(stderr.contains("not logged in"), "{stderr}");
-        }
-        other => panic!("unexpected {other:?}"),
-    }
-}
-
-#[tokio::test]
-async fn drop_terminates_and_reaps_the_child() {
-    let fake = Fake::new();
-    let cwd = TempDir::new().unwrap();
-    let mut config = fake.config(cwd.path());
-    config.env.insert("FAKE_ACP_IGNORE_EOF".into(), "1".into());
-    let session = maestro_acp::spawn(config).await.expect("spawn");
-
-    drop(session);
-
-    fake.wait_for_log("signal SIGTERM").await;
-    fake.wait_for_exit().await;
-}
-
-fn chunk_text(n: &maestro_acp::schema::SessionNotification) -> String {
-    match &n.update {
-        SessionUpdate::AgentMessageChunk(chunk) => match &chunk.content {
-            ContentBlock::Text(t) => t.text.clone(),
-            other => panic!("unexpected content {other:?}"),
-        },
-        other => panic!("unexpected update {other:?}"),
-    }
-}
-
-#[tokio::test]
-async fn load_session_resumes_the_stored_id_and_drops_the_replay() {
-    let fake = Fake::new();
-    let cwd = TempDir::new().unwrap();
-    let mut config = fake
-        .config(cwd.path())
-        .adapter(AcpAdapter::Codex)
-        .load_session("fake-old");
-    config.env.insert("FAKE_ACP_LOAD_REPLAY".into(), "3".into());
-
-    let session = maestro_acp::spawn(config).await.expect("spawn");
-    assert_eq!(session.session_id(), "fake-old");
-    let log = fake.log();
-    assert!(
-        log.contains("recv session/load sessionId=fake-old"),
-        "{log}"
-    );
-    assert!(!log.contains("recv session/new"), "{log}");
-
-    // The three replayed chunks never reach the receiver: the event log
-    // already holds them. The first notification after the response does.
-    let mut updates = session.take_updates().expect("updates");
-    let first = tokio::time::timeout(Duration::from_secs(5), updates.recv())
-        .await
-        .expect("update within 5s")
-        .expect("channel open");
-    assert_eq!(chunk_text(&first), "hello after load");
-    // Nothing queued behind it either.
-    tokio::time::sleep(Duration::from_millis(100)).await;
-    assert!(updates.try_recv().is_err(), "replay leaked through");
-
-    session
-        .terminate(Duration::from_millis(100), Duration::from_secs(2))
-        .await;
-}
-
-#[tokio::test]
-async fn load_session_requires_the_load_capability() {
-    let fake = Fake::new();
-    let cwd = TempDir::new().unwrap();
-    let mut config = fake
-        .config(cwd.path())
-        .adapter(AcpAdapter::Codex)
-        .load_session("fake-old");
-    config.env.insert("FAKE_ACP_NO_LOAD".into(), "1".into());
-
-    let err = maestro_acp::spawn(config)
-        .await
-        .expect_err("no loadSession");
-    assert!(matches!(err, AcpError::Handshake(_)), "{err}");
-    assert!(err.to_string().contains("loadSession"), "{err}");
-    assert!(!fake.log().contains("recv session/load"), "{}", fake.log());
-}
-
-#[tokio::test]
-async fn load_session_error_fails_the_spawn() {
-    let fake = Fake::new();
-    let cwd = TempDir::new().unwrap();
-    let mut config = fake
-        .config(cwd.path())
-        .adapter(AcpAdapter::Codex)
-        .load_session("fake-old");
-    config.env.insert("FAKE_ACP_LOAD_FAIL".into(), "1".into());
-
-    let err = maestro_acp::spawn(config).await.expect_err("load fails");
-    assert!(matches!(err, AcpError::Handshake(_)), "{err}");
-    assert!(err.to_string().contains("fake load failure"), "{err}");
-}
-
-/// End to end against the installed `claude-code-acp`. Needs Claude auth,
-/// takes seconds, so it is opt-in: `cargo test -p maestro-acp -- --ignored`.
-#[tokio::test]
-#[ignore]
-async fn real_adapter_handshake() {
-    let cwd = TempDir::new().unwrap();
-    let session = maestro_acp::spawn(SpawnConfig::new(cwd.path(), HashMap::new()))
-        .await
-        .expect("real claude-code-acp handshake");
-    assert!(!session.session_id().is_empty());
-    assert!(pid_alive(session.pid()));
-    session
-        .terminate(maestro_acp::CANCEL_GRACE, maestro_acp::TERM_GRACE)
-        .await;
-    assert!(session.has_exited());
-}
-
-/// End to end against the maintained Codex adapter. It needs a locally
-/// authenticated Codex CLI, so CI runs it only when explicitly requested.
-#[tokio::test]
-#[ignore]
-async fn real_codex_adapter_handshake() {
-    let cwd = TempDir::new().unwrap();
-    let session =
-        maestro_acp::spawn(SpawnConfig::new(cwd.path(), HashMap::new()).adapter(AcpAdapter::Codex))
-            .await
-            .expect("real codex-acp handshake");
-    assert!(!session.session_id().is_empty());
-    assert!(pid_alive(session.pid()));
-    session
-        .terminate(maestro_acp::CANCEL_GRACE, maestro_acp::TERM_GRACE)
-        .await;
-    assert!(session.has_exited());
-}

crates/maestro-cli/src/attach.rs

@@ -19,12 +19,6 @@ use tokio_tungstenite::tungstenite::Message;
 pub enum AttachError {
     #[error("ws: {0}")]
     WebSocket(#[from] tokio_tungstenite::tungstenite::Error),
-    #[error("daemon returned {status} ({code}): {message}")]
-    Rejected {
-        status: String,
-        code: String,
-        message: String,
-    },
     #[error("io: {0}")]
     Io(#[from] io::Error),
     #[error("termios: {0}")]
@@ -38,21 +32,6 @@ pub enum AttachError {
 }
 
 impl AttachError {
-    fn from_websocket(error: tokio_tungstenite::tungstenite::Error) -> Self {
-        if let tokio_tungstenite::tungstenite::Error::Http(response) = &error {
-            if let Some(body) = response.body().as_deref() {
-                if let Ok(error_body) = serde_json::from_slice::<maestro_protocol::ApiError>(body) {
-                    return Self::Rejected {
-                        status: response.status().to_string(),
-                        code: error_body.error.code,
-                        message: error_body.error.message,
-                    };
-                }
-            }
-        }
-        Self::WebSocket(error)
-    }
-
     /// True when the failure was an inability to reach the WS endpoint at the
     /// transport level (connection refused), as opposed to an HTTP-level
     /// rejection from a daemon that did answer.
@@ -132,9 +111,7 @@ fn current_winsize() -> Option<(u16, u16)> {
 /// byte that exits cleanly without killing the session.
 #[allow(clippy::result_large_err)]
 pub async fn run_attach_url(url: &str, detach_byte: u8) -> Result<(), AttachError> {
-    let (ws, _resp) = tokio_tungstenite::connect_async(url)
-        .await
-        .map_err(AttachError::from_websocket)?;
+    let (ws, _resp) = tokio_tungstenite::connect_async(url).await?;
     let (mut sink, mut stream) = ws.split();
 
     let raw = RawTty::enable()?;
@@ -256,25 +233,4 @@ mod tests {
             Err(AttachError::InvalidDetachKey(_))
         ));
     }
-
-    #[test]
-    fn attach_surfaces_structured_handshake_errors() {
-        let body = serde_json::to_vec(&maestro_protocol::ApiError::new(
-            "not_terminal",
-            "session is not a terminal session",
-        ))
-        .unwrap();
-        let response = tokio_tungstenite::tungstenite::http::Response::builder()
-            .status(409)
-            .body(Some(body))
-            .unwrap();
-
-        let error =
-            AttachError::from_websocket(tokio_tungstenite::tungstenite::Error::Http(response));
-
-        assert_eq!(
-            error.to_string(),
-            "daemon returned 409 Conflict (not_terminal): session is not a terminal session"
-        );
-    }
 }

crates/maestro-cli/src/cli.rs

@@ -41,8 +41,8 @@ pub enum Command {
     Attach(AttachArgs),
     /// Kill a session by ID.
     Kill(KillArgs),
-    /// Send text to a running session. Terminal sessions receive raw
-    /// keystrokes; structured sessions receive an ACP prompt.
+    /// Type text into a running session, as if it had been typed on an
+    /// attached terminal.
     Send(SendArgs),
     /// Install or update the agent activity hook (#106).
     Hooks(HooksArgs),
@@ -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,
@@ -133,7 +125,7 @@ pub struct KillArgs {
     /// Session ID to kill.
     pub session_id: Uuid,
     /// End the session even when its worktree holds unsaved work (#81). The
-    /// worktree is removed along with the session.
+    /// worktree is left on disk — never removed.
     #[arg(long)]
     pub force: bool,
 }

crates/maestro-cli/src/dispatch.rs

@@ -96,32 +96,20 @@ pub async fn dispatch(
 }
 
 /// `maestro hooks install` (#106): write the shipped hook script under the
-/// user's data dir and register it in every agent's hook file. Idempotent and
-/// foreign-hook-preserving — the guarantees live in [`maestro_hooks`]. One
-/// agent failing is reported and does not stop the others.
+/// user's data dir and register it in their Claude Code settings. Idempotent
+/// and foreign-hook-preserving — the guarantees live in [`maestro_hooks`].
 #[allow(clippy::result_large_err)]
 fn run_hooks_install() -> Result<(), CliError> {
     let home = dirs::home_dir().ok_or(CliError::NoHome)?;
-    let script = maestro_hooks::script_path(&home);
-    for (target, result) in maestro_hooks::install_for_home(&home) {
-        let agent = target.label();
-        let settings = target.settings_path(&home);
-        match result {
-            Ok(true) => {
-                println!(
-                    "installed {agent} activity hook: {} → {}",
-                    script.display(),
-                    settings.display()
-                );
-                if target == maestro_hooks::Target::Codex {
-                    // Codex will not run a hook it has not been told to
-                    // trust, and that approval is the operator's to give.
-                    println!("  codex will ask you to trust this hook the next time it starts");
-                }
-            }
-            Ok(false) => println!("{agent} activity hook already up to date"),
-            Err(e) => eprintln!("{agent} activity hook not installed: {e}"),
-        }
+    let changed = maestro_hooks::install_for_home(&home)?;
+    if changed {
+        println!(
+            "installed claude-code activity hook: {} → {}",
+            maestro_hooks::script_path(&home).display(),
+            maestro_hooks::settings_path(&home).display()
+        );
+    } else {
+        println!("claude-code activity hook already up to date");
     }
     Ok(())
 }

crates/maestro-cli/src/sessions.rs

@@ -3,10 +3,10 @@
 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,
+    Session, SessionStatus, WorktreeSpec,
 };
 use serde_json::Value;
 
@@ -51,33 +51,15 @@ pub async fn run_spawn(client: &DaemonClient, args: SpawnArgs) -> Result<Session
     };
 
     let body = CreateSessionRequest {
-        view: spawn_view(&args),
         cwd: args.cwd.clone(),
         command: args.command.clone(),
         env,
         metadata,
         worktree,
-        auto_approve: false,
     };
     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.
@@ -130,12 +112,9 @@ pub fn resolve_session(sessions: &[Session], needle: &str) -> Result<uuid::Uuid,
 /// `maestro send`. Answers with the session that was typed into, so the
 /// caller can name it once the daemon has accepted the text.
 ///
-/// Terminal sessions get raw keystrokes via `send_input`; structured sessions
-/// get an ACP prompt via `send_structured_prompt` (`--no-enter` is ignored
-/// there — ACP prompts are always complete messages).
-///
-/// Text comes from the arguments, or from stdin when there is none — the
-/// shape a heredoc or a pipe wants.
+/// A bare ID skips the catalog fetch; anything else needs the list to match
+/// against. Text comes from the arguments, or from stdin when there is none —
+/// the shape a heredoc or a pipe wants.
 #[allow(clippy::result_large_err)]
 pub async fn run_send(
     client: &DaemonClient,
@@ -158,28 +137,19 @@ pub async fn run_send(
         return Err(CliError::NothingToSend);
     }
 
-    // We always need the session list: even a bare UUID needs the view field
-    // to decide which endpoint to hit.
-    let sessions = client.list_sessions().await?;
-    let id = resolve_session(&sessions, &args.session)?;
-    let view = sessions
-        .iter()
-        .find(|s| s.id == id)
-        .map(|s| s.view)
-        .unwrap_or(SessionView::Terminal);
+    let id = match uuid::Uuid::parse_str(args.session.trim()) {
+        Ok(id) => id,
+        Err(_) => {
+            let sessions = client.list_sessions().await?;
+            resolve_session(&sessions, &args.session)?
+        }
+    };
 
-    match view {
-        SessionView::Structured => {
-            client.send_structured_prompt(id, &text).await?;
-        }
-        SessionView::Terminal => {
-            let req = SendInputRequest {
-                text,
-                submit: !args.no_enter,
-            };
-            client.send_input(id, &req).await?;
-        }
-    }
+    let req = SendInputRequest {
+        text,
+        submit: !args.no_enter,
+    };
+    client.send_input(id, &req).await?;
     Ok(id)
 }
 
@@ -208,8 +178,8 @@ fn print_session_table(out: &mut impl Write, sessions: &[Session], info: &Daemon
     }
     writeln!(
         out,
-        "  {:<36}  {:<8}  {:<10}  {:<9}  {:<28}  {:<40}  {}",
-        "ID", "STATUS", "VIEW", "ACTIVITY", "DIR", "COMMAND", "BLOCKED"
+        "  {:<36}  {:<8}  {:<9}  {:<28}  {:<40}  {}",
+        "ID", "STATUS", "ACTIVITY", "DIR", "COMMAND", "BLOCKED"
     )
     .ok();
     for s in sorted {
@@ -218,17 +188,13 @@ fn print_session_table(out: &mut impl Write, sessions: &[Session], info: &Daemon
         let status = match s.status {
             SessionStatus::Running => "running",
             SessionStatus::Dead => "dead",
-        };
-        let view = match s.view {
-            SessionView::Terminal => "terminal",
-            SessionView::Structured => "structured",
+            SessionStatus::Dormant => "dormant",
         };
         let activity = match s.activity {
             ActivityState::Active => "active",
             ActivityState::Idle => "idle",
             ActivityState::AwaitingInput => "awaiting",
             ActivityState::Error => "error",
-            ActivityState::Starting => "starting",
         };
         // Show the live foreground command alongside the spawn command when
         // the daemon has observed one that differs (NAP-340).
@@ -241,8 +207,8 @@ fn print_session_table(out: &mut impl Write, sessions: &[Session], info: &Daemon
         let blocked = blocked_label(s);
         writeln!(
             out,
-            "  {:<36}  {:<8}  {:<10}  {:<9}  {:<28}  {:<40}  {blocked}",
-            s.id, status, view, activity, dir, command
+            "  {:<36}  {:<8}  {:<9}  {:<28}  {:<40}  {blocked}",
+            s.id, status, activity, dir, command
         )
         .ok();
     }
@@ -264,70 +230,13 @@ mod tests {
     use std::path::PathBuf;
 
     use chrono::{TimeZone, Utc};
-    use maestro_protocol::{ActivityState, Session, SessionStatus, SessionView};
+    use maestro_protocol::{ActivityState, Session, SessionStatus};
     use uuid::Uuid;
 
     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(),
             id: Uuid::from_u128(id),
             cwd: PathBuf::from(cwd),
             command: command.into(),
@@ -344,9 +253,7 @@ mod tests {
             current_cwd: None,
             blocked_work: None,
             last_focused_at: None,
-            acp_session_id: None,
-            auto_approve: false,
-            queued_prompts: Vec::new(),
+            agent_session_id: None,
         }
     }
 
@@ -378,22 +285,6 @@ mod tests {
         assert!(s.contains("idle"), "{s}");
     }
 
-    #[test]
-    fn table_exposes_terminal_and_structured_views() {
-        let terminal = session("/tmp", "bash", 1);
-        let mut structured = session("/tmp", "claude", 2);
-        structured.view = SessionView::Structured;
-
-        let mut buf = Vec::new();
-        super::print_session_table(&mut buf, &[terminal, structured], &info(""));
-        let out = String::from_utf8(buf).unwrap();
-        let lines: Vec<&str> = out.lines().collect();
-        let header = lines.iter().position(|line| line.contains("VIEW")).unwrap();
-
-        assert!(lines[header + 1].contains("terminal"), "{out}");
-        assert!(lines[header + 2].contains("structured"), "{out}");
-    }
-
     #[test]
     fn live_cwd_overrides_spawn_dir_in_table() {
         let mut s = session("/home/naps/maestro", "bash", 1);

crates/maestro-cli/tests/against_mock_daemon.rs

@@ -2,7 +2,7 @@
 //! was unit-tested, but nothing exercised the client, the error decoding, or
 //! the unreachable-daemon path without compiling and forking a real daemon.
 
-use maestro_protocol::{DaemonClient, DaemonInfo, SessionView};
+use maestro_protocol::{DaemonClient, DaemonInfo};
 use maestro_testing::{session, MockDaemon};
 use uuid::Uuid;
 
@@ -28,7 +28,7 @@ async fn info_carries_version_and_presets() {
             id: "claude".into(),
             label: "Claude".into(),
             command: "claude".into(),
-            auto_approve: false,
+            resume_command: None,
         }],
         ..Default::default()
     });
@@ -92,13 +92,11 @@ async fn spawn_round_trips_through_the_daemon() {
     let created = mock
         .client()
         .create_session(&maestro_protocol::CreateSessionRequest {
-            view: Default::default(),
             cwd: "/home/mock".into(),
             command: "bash".into(),
             env: Default::default(),
             metadata: Default::default(),
             worktree: None,
-            auto_approve: false,
         })
         .await
         .expect("create");
@@ -202,35 +200,6 @@ async fn send_resolves_a_session_by_name() {
     assert_eq!(sent, id);
 }
 
-/// A structured session routes through the ACP prompt endpoint, not the
-/// terminal input one — `--no-enter` is irrelevant (ACP prompts are
-/// complete messages).
-#[tokio::test]
-async fn send_to_structured_session_uses_acp_prompt() {
-    let mock = MockDaemon::start().await;
-    let id = Uuid::from_u128(13);
-    let mut s = session(id, "/tmp", "claude");
-    s.view = SessionView::Structured;
-    mock.add_session(s);
-
-    let args = maestro_cli::cli::SendArgs {
-        session: id.to_string(),
-        text: vec!["fix".into(), "the".into(), "tests".into()],
-        no_enter: false,
-    };
-    let sent = maestro_cli::sessions::run_send(&mock.client(), &args, &mut std::io::empty())
-        .await
-        .expect("send");
-
-    assert_eq!(sent, id);
-    // Terminal input must stay empty — the message went through ACP.
-    assert!(mock.inputs().is_empty());
-    let prompts = mock.structured_prompts();
-    assert_eq!(prompts.len(), 1);
-    assert_eq!(prompts[0].0, id);
-    assert_eq!(prompts[0].1.prompt, "fix the tests");
-}
-
 #[tokio::test]
 async fn send_to_an_unknown_session_fails_without_typing_anything() {
     let mock = MockDaemon::start().await;

crates/maestro-config/src/lib.rs

@@ -129,6 +129,80 @@ pub struct DaemonSection {
     /// `Some(0)` disables history entirely (no log written, no recents read).
     #[serde(default)]
     pub spawn_history_days: Option<u32>,
+    /// What recovery does with sessions that outlived their tmux server —
+    /// after a host reboot, or any restart that finds a sidecar with no pane
+    /// (#167). Default [`ResumeOnBoot::Dormant`].
+    #[serde(default, deserialize_with = "deserialize_resume_on_boot")]
+    pub resume_on_boot: Option<ResumeOnBoot>,
+}
+
+impl DaemonSection {
+    /// The configured `[daemon].resume_on_boot`, or the safe default:
+    /// recovered-but-dead sessions wait for the operator.
+    pub fn resume_on_boot(&self) -> ResumeOnBoot {
+        self.resume_on_boot.unwrap_or_default()
+    }
+}
+
+/// `[daemon].resume_on_boot` — what recovery does with a session whose tmux
+/// pane is gone but whose sidecar is still on disk (#167).
+///
+/// Resuming agents unattended seconds after a reboot is a foot-gun: they run
+/// with whatever flags they were spawned with, with nobody watching. So the
+/// default waits for a human, and `auto` is opted into per host.
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
+pub enum ResumeOnBoot {
+    /// Register each one `Dormant` and wait for the operator to resume it.
+    #[default]
+    Dormant,
+    /// Resume each one during recovery, on the same path a client's
+    /// `POST /api/sessions/:id/resume` takes.
+    Auto,
+    /// Prune the sidecars instead: a reboot is a clean slate.
+    Never,
+}
+
+/// Every `[daemon].resume_on_boot` name and its variant, in documentation
+/// order.
+pub const RESUME_ON_BOOT_POLICIES: &[(&str, ResumeOnBoot)] = &[
+    ("dormant", ResumeOnBoot::Dormant),
+    ("auto", ResumeOnBoot::Auto),
+    ("never", ResumeOnBoot::Never),
+];
+
+impl ResumeOnBoot {
+    /// The name this policy is spelled with in the config file and in logs.
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            ResumeOnBoot::Dormant => "dormant",
+            ResumeOnBoot::Auto => "auto",
+            ResumeOnBoot::Never => "never",
+        }
+    }
+}
+
+fn deserialize_resume_on_boot<'de, D>(deserializer: D) -> Result<Option<ResumeOnBoot>, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    let raw = Option::<String>::deserialize(deserializer)?;
+    raw.map(|name| {
+        RESUME_ON_BOOT_POLICIES
+            .iter()
+            .find(|(n, _)| *n == name)
+            .map(|(_, policy)| *policy)
+            .ok_or_else(|| {
+                let known = RESUME_ON_BOOT_POLICIES
+                    .iter()
+                    .map(|(n, _)| format!("{n:?}"))
+                    .collect::<Vec<_>>()
+                    .join(", ");
+                D::Error::custom(format!(
+                    "invalid [daemon].resume_on_boot {name:?}; expected one of {known}"
+                ))
+            })
+    })
+    .transpose()
 }
 
 /// `[tui]` — `maestro tui` settings (NAP-275 epic, phase 2 NAP-277).
@@ -313,19 +387,19 @@ pub fn builtin_presets() -> Vec<SpawnPreset> {
             id: "claude".into(),
             label: "Claude".into(),
             command: "claude".into(),
-            auto_approve: false,
+            resume_command: Some("claude --resume {agent_session}".into()),
         },
         SpawnPreset {
             id: "opencode".into(),
             label: "opencode".into(),
             command: "opencode".into(),
-            auto_approve: false,
+            resume_command: None,
         },
         SpawnPreset {
             id: "zsh".into(),
             label: "Shell".into(),
             command: "zsh".into(),
-            auto_approve: false,
+            resume_command: None,
         },
     ]
 }
@@ -337,7 +411,7 @@ pub fn custom_preset() -> SpawnPreset {
         id: CUSTOM_PRESET_ID.into(),
         label: "Custom…".into(),
         command: String::new(),
-        auto_approve: false,
+        resume_command: None,
     }
 }
 
@@ -511,6 +585,18 @@ auto_install = false
         assert!(custom.command.is_empty());
     }
 
+    #[test]
+    fn builtin_claude_preset_resumes_by_agent_session() {
+        let claude = builtin_presets()
+            .into_iter()
+            .find(|preset| preset.id == "claude")
+            .expect("Claude preset");
+        assert_eq!(
+            claude.resume_command.as_deref(),
+            Some("claude --resume {agent_session}")
+        );
+    }
+
     #[test]
     fn spawn_presets_override_replaces_builtins() {
         // Present list replaces the built-ins entirely; custom still appended.
@@ -519,7 +605,7 @@ auto_install = false
                 id: "fish".into(),
                 label: "fish".into(),
                 command: "fish".into(),
-                auto_approve: false,
+                resume_command: None,
             }]),
             ..Default::default()
         };
@@ -556,7 +642,7 @@ auto_install = false
                 id: "  ".into(),
                 label: "x".into(),
                 command: "x".into(),
-                auto_approve: false,
+                resume_command: None,
             }]),
             ..Default::default()
         };
@@ -567,7 +653,7 @@ auto_install = false
                 id: "x".into(),
                 label: "x".into(),
                 command: "".into(),
-                auto_approve: false,
+                resume_command: None,
             }]),
             ..Default::default()
         };
@@ -585,13 +671,13 @@ auto_install = false
                     id: "a".into(),
                     label: "a".into(),
                     command: "a".into(),
-                    auto_approve: false,
+                    resume_command: None,
                 },
                 SpawnPreset {
                     id: "a".into(),
                     label: "a2".into(),
                     command: "a2".into(),
-                    auto_approve: false,
+                    resume_command: None,
                 },
             ]),
             ..Default::default()
@@ -606,7 +692,7 @@ auto_install = false
                 id: "custom".into(),
                 label: "Custom".into(),
                 command: "whatever".into(),
-                auto_approve: false,
+                resume_command: None,
             }]),
             ..Default::default()
         };
@@ -642,6 +728,27 @@ presets = [
         assert_eq!(ids, ["claude", "zsh", "custom"]);
     }
 
+    #[test]
+    fn spawn_preset_parses_resume_command_from_issue_example() {
+        let cfg = toml::from_str::<MaestroConfigFile>(
+            r#"
+[spawn]
+presets = [
+  { id = "claude", command = "claude --dangerously-skip-permissions", resume_command = "claude --dangerously-skip-permissions --resume {agent_session}" }
+]
+"#,
+        )
+        .expect("issue #165 example parses");
+
+        let preset = &cfg.spawn.presets.expect("configured presets")[0];
+        assert_eq!(preset.id, "claude");
+        assert_eq!(preset.command, "claude --dangerously-skip-permissions");
+        assert_eq!(
+            preset.resume_command.as_deref(),
+            Some("claude --dangerously-skip-permissions --resume {agent_session}")
+        );
+    }
+
     #[test]
     fn spawn_project_scan_fields_default_to_none() {
         // Absent [spawn].project_* → None; the daemon applies its own defaults.
@@ -742,4 +849,27 @@ bind_addr = "127.0.0.1:9090"
         );
         assert_eq!(cfg.resolve_daemon_url(None), "http://explicit:1");
     }
+
+    #[test]
+    fn resume_on_boot_defaults_to_dormant_and_parses_every_policy() {
+        assert_eq!(
+            MaestroConfigFile::default().daemon.resume_on_boot(),
+            ResumeOnBoot::Dormant,
+            "an absent policy is the safe one"
+        );
+        for (name, expected) in RESUME_ON_BOOT_POLICIES {
+            let cfg = file_with(&format!("[daemon]\nresume_on_boot = \"{name}\"\n"));
+            assert_eq!(cfg.daemon.resume_on_boot(), *expected, "{name}");
+            assert_eq!(expected.as_str(), *name);
+        }
+    }
+
+    #[test]
+    fn resume_on_boot_rejects_an_unknown_policy() {
+        let err = toml::from_str::<MaestroConfigFile>("[daemon]\nresume_on_boot = \"maybe\"\n")
+            .expect_err("unknown policy must not silently fall back");
+        let msg = err.to_string();
+        assert!(msg.contains("resume_on_boot"), "{msg}");
+        assert!(msg.contains("\"auto\""), "{msg}");
+    }
 }

crates/maestro-daemon/Cargo.toml

@@ -28,7 +28,6 @@ dirs.workspace = true
 futures-util.workspace = true
 include_dir = { workspace = true, optional = true }
 libc.workspace = true
-maestro-acp.workspace = true
 mime_guess = { workspace = true, optional = true }
 maestro-config.workspace = true
 maestro-hooks = { workspace = true, default-features = false }
@@ -43,7 +42,6 @@ tracing-subscriber.workspace = true
 uuid.workspace = true
 
 [dev-dependencies]
-libc.workspace = true
 reqwest.workspace = true
 tokio-tungstenite.workspace = true
 urlencoding = "2"

crates/maestro-daemon/src/activity.rs

@@ -66,23 +66,6 @@ pub fn decide(idle_for: Duration, awaiting_input: bool) -> ActivityState {
     }
 }
 
-/// Derive a structured session's sidebar state from its ACP projection.
-pub fn decide_structured(
-    turn_active: bool,
-    pending_approval: bool,
-    turn_failed: bool,
-) -> ActivityState {
-    if turn_failed {
-        ActivityState::Error
-    } else if pending_approval {
-        ActivityState::AwaitingInput
-    } else if turn_active {
-        ActivityState::Active
-    } else {
-        ActivityState::Idle
-    }
-}
-
 /// How long a session's pane must be continuously focused (a client's pane,
 /// not a sidebar highlight) before an `AwaitingInput` glow clears: the
 /// operator has looked, so the rail stops asking for attention.
@@ -153,17 +136,6 @@ mod tests {
         );
     }
 
-    #[test]
-    fn structured_activity_follows_lifecycle_with_approval_precedence() {
-        assert_eq!(decide_structured(false, false, false), ActivityState::Idle);
-        assert_eq!(decide_structured(true, false, false), ActivityState::Active);
-        assert_eq!(
-            decide_structured(true, true, false),
-            ActivityState::AwaitingInput
-        );
-        assert_eq!(decide_structured(false, false, true), ActivityState::Error);
-    }
-
     #[test]
     fn report_is_in_force_until_exactly_its_expiry() {
         let ttl = Duration::from_secs(300);

crates/maestro-daemon/src/boot_id.rs

@@ -0,0 +1,65 @@
+//! Tells a daemon restart from a host reboot (#164).
+//!
+//! `/proc/sys/kernel/random/boot_id` is fixed for the life of the kernel and
+//! changes on every boot. [`SessionManager::recover`] compares it against the
+//! value it stored on the previous run and logs which of the two it was.
+//!
+//! It does not decide liveness (#174). A boot id changes without the tmux
+//! server dying whenever the state directory is restored, a VM or container
+//! snapshot is rolled back, or the `boot_id` file is truncated — so recovery
+//! always probes `tmux list-sessions` and the boot id only says whether a
+//! server that did not answer is coming back.
+
+use std::path::Path;
+
+/// Where the daemon reads the running kernel's boot id. Behind a trait so
+/// tests can simulate a changed (or unreadable) boot id without rebooting the
+/// machine.
+pub trait BootIdSource: std::fmt::Debug + Send + Sync + 'static {
+    /// Current boot id, or `None` if it can't be determined (non-Linux,
+    /// restricted `/proc`, missing or empty file).
+    fn current(&self) -> Option<String>;
+}
+
+/// Production source: `/proc/sys/kernel/random/boot_id`.
+#[derive(Debug, Default)]
+pub struct ProcBootId;
+
+impl BootIdSource for ProcBootId {
+    fn current(&self) -> Option<String> {
+        read_boot_id(Path::new("/proc/sys/kernel/random/boot_id"))
+    }
+}
+
+fn read_boot_id(path: &Path) -> Option<String> {
+    let contents = std::fs::read_to_string(path).ok()?;
+    let trimmed = contents.trim();
+    (!trimmed.is_empty()).then(|| trimmed.to_string())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn reads_trimmed_contents() {
+        let dir = tempfile::tempdir().unwrap();
+        let path = dir.path().join("boot_id");
+        std::fs::write(&path, "abc-123\n").unwrap();
+        assert_eq!(read_boot_id(&path).as_deref(), Some("abc-123"));
+    }
+
+    #[test]
+    fn missing_file_returns_none() {
+        let dir = tempfile::tempdir().unwrap();
+        assert_eq!(read_boot_id(&dir.path().join("missing")), None);
+    }
+
+    #[test]
+    fn empty_file_returns_none() {
+        let dir = tempfile::tempdir().unwrap();
+        let path = dir.path().join("boot_id");
+        std::fs::write(&path, "\n").unwrap();
+        assert_eq!(read_boot_id(&path), None);
+    }
+}

crates/maestro-daemon/src/cli.rs

@@ -51,23 +51,17 @@ async fn run(config_override: Option<PathBuf>) -> Result<(), Box<dyn Error>> {
     // First-start hook auto-install (#106). Best-effort, before serving: a
     // session spawned right away should already carry the hook.
     if config.hooks_auto_install {
-        for (target, outcome) in crate::hooks::auto_install(&config.home_dir) {
-            let agent = target.label();
-            match outcome {
-                crate::hooks::AutoInstallOutcome::Installed => {
-                    tracing::info!(agent, "installed activity hook (#106)");
-                }
-                crate::hooks::AutoInstallOutcome::Upgraded => {
-                    tracing::info!(agent, "updated activity hook to this build (#106)");
-                }
-                crate::hooks::AutoInstallOutcome::Failed => {
-                    tracing::warn!(
-                        agent,
-                        "hooks auto-install failed; run `maestro hooks install` manually"
-                    );
-                }
-                _ => {}
+        match crate::hooks::auto_install(&config.home_dir) {
+            crate::hooks::AutoInstallOutcome::Installed => {
+                tracing::info!("installed claude-code activity hook (#106)");
             }
+            crate::hooks::AutoInstallOutcome::Upgraded => {
+                tracing::info!("updated claude-code activity hook to this build (#106)");
+            }
+            crate::hooks::AutoInstallOutcome::Failed => {
+                tracing::warn!("hooks auto-install failed; run `maestro hooks install` manually");
+            }
+            _ => {}
         }
     }
     // No worktree dir to pre-create: without an override the worktrees live
@@ -89,7 +83,17 @@ async fn run(config_override: Option<PathBuf>) -> Result<(), Box<dyn Error>> {
     .with_spawn_history(crate::spawn_history::SpawnHistory::new(
         config.spawn_history_path(),
         config.spawn_history_days,
-    ));
+    ))
+    // #171: mirror PTY scrollback so a resumed session opens on what it was
+    // showing, instead of a blank pane.
+    .with_scrollback(config.scrollback_dir())
+    .with_boot_id(
+        config.boot_id_path(),
+        std::sync::Arc::new(crate::boot_id::ProcBootId),
+    )
+    // #167: recovery needs the presets to resolve a resumed session's command,
+    // so `auto` runs the same resume a client's POST would.
+    .with_resume_policy(config.resume_on_boot, config.spawn_presets.clone());
     // Spawned sessions learn where to report back (#103). Derived from the
     // configured bind address; set before any spawn can happen.
     manager.set_daemon_url(format!("http://{}", config.bind_addr));
@@ -106,7 +110,7 @@ async fn run(config_override: Option<PathBuf>) -> Result<(), Box<dyn Error>> {
     projects.start_background_refresh();
 
     let router = local_api::router(local_api::state_for(
-        manager.clone(),
+        manager,
         config.hostname.clone(),
         config.home_dir.clone(),
         config.spawn_presets.clone(),
@@ -118,22 +122,9 @@ async fn run(config_override: Option<PathBuf>) -> Result<(), Box<dyn Error>> {
     let bound = listener.local_addr()?;
     tracing::info!(addr = %bound, "API listening");
 
-    // Ctrl-C at a terminal or SIGTERM from systemd: either one is a
-    // shutdown, and both must reach the adapter children below (#134). The
-    // unit's `KillMode=process` signals only the daemon, so nothing else
-    // would end them.
-    let shutdown_manager = manager.clone();
-    let shutdown = async move {
-        let mut sigterm = tokio::signal::unix::signal(tokio::signal::unix::SignalKind::terminate())
-            .expect("install SIGTERM handler");
-        tokio::select! {
-            _ = tokio::signal::ctrl_c() => tracing::info!("ctrl-c received — shutting down"),
-            _ = sigterm.recv() => tracing::info!("SIGTERM received — shutting down"),
-        }
-        // Axum waits for upgraded WebSockets to drain. Structured children
-        // must be settled before that wait, while the signal path still owns
-        // the shutdown order (#179).
-        shutdown_manager.shutdown().await;
+    let shutdown = async {
+        let _ = tokio::signal::ctrl_c().await;
+        tracing::info!("ctrl-c received — shutting down");
     };
 
     axum::serve(listener, router)

crates/maestro-daemon/src/config.rs

@@ -97,6 +97,10 @@ pub struct DaemonConfig {
     /// never binds it itself; it serves it so the web client and the TUI read
     /// one knob.
     pub leader: String,
+    /// What recovery does with sessions whose tmux pane is gone but whose
+    /// sidecar survives (#167): `[daemon].resume_on_boot`, default
+    /// [`maestro_config::ResumeOnBoot::Dormant`].
+    pub resume_on_boot: maestro_config::ResumeOnBoot,
 }
 
 impl DaemonConfig {
@@ -112,6 +116,18 @@ impl DaemonConfig {
     pub fn spawn_history_path(&self) -> PathBuf {
         self.state_dir.join("spawn-history.jsonl")
     }
+
+    /// Where PTY scrollback is mirrored so a resumed session opens on what
+    /// it printed before (#171): `<state_dir>/scrollback`.
+    pub fn scrollback_dir(&self) -> PathBuf {
+        self.state_dir.join("scrollback")
+    }
+
+    /// Where recovery records the kernel boot id it saw last (#164):
+    /// `<state_dir>/boot_id`.
+    pub fn boot_id_path(&self) -> PathBuf {
+        self.state_dir.join("boot_id")
+    }
 }
 
 /// Env-var overrides applied by [`load_config`]. Tests pass explicit
@@ -143,6 +159,8 @@ pub fn load_config(path: &Path, env: EnvOverrides) -> Result<DaemonConfig, Confi
     // validation (#22/#26).
     let spawn_presets = file.spawn.resolve()?;
 
+    let resume_on_boot = daemon.resume_on_boot();
+
     let hostname = daemon.hostname.unwrap_or_else(system_hostname);
     let home_dir = dirs::home_dir()
         .map(|p| p.to_string_lossy().into_owned())
@@ -203,6 +221,7 @@ pub fn load_config(path: &Path, env: EnvOverrides) -> Result<DaemonConfig, Confi
         project_scan_depth,
         hooks_auto_install: file.hooks.auto_install(),
         leader: file.tui.leader().to_string(),
+        resume_on_boot,
     })
 }
 
@@ -283,6 +302,34 @@ auto_install = false
         assert!(!cfg.hooks_auto_install);
     }
 
+    #[test]
+    fn resume_on_boot_defaults_to_dormant_and_reads_the_file() {
+        let dir = tempfile::tempdir().unwrap();
+        let path = dir.path().join("config.toml");
+        std::fs::write(&path, "").unwrap();
+        assert_eq!(
+            load_config(&path, EnvOverrides::default())
+                .unwrap()
+                .resume_on_boot,
+            maestro_config::ResumeOnBoot::Dormant
+        );
+
+        std::fs::write(
+            &path,
+            r#"
+[daemon]
+resume_on_boot = "auto"
+"#,
+        )
+        .unwrap();
+        assert_eq!(
+            load_config(&path, EnvOverrides::default())
+                .unwrap()
+                .resume_on_boot,
+            maestro_config::ResumeOnBoot::Auto
+        );
+    }
+
     #[test]
     fn empty_file_defaults_everything() {
         let dir = tempfile::tempdir().unwrap();

crates/maestro-daemon/src/gitroot.rs

@@ -80,22 +80,13 @@ mod tests {
     }
 
     #[test]
-    fn non_repo_dir_does_not_find_root_inside_fixture() {
-        // The fixture has no `.git`, so `find_root` must not return a path
-        // inside it. On hosts where an ancestor of the temp dir *is* a repo
-        // (e.g. `/tmp` lives inside a checkout), the function legitimately
-        // returns that ancestor — the test only asserts the fixture itself
-        // was not mistaken for a repo.
+    fn non_repo_dir_is_none() {
+        // A temp dir with no `.git` anywhere up the chain. Use the temp root so
+        // the walk can't accidentally hit a real repo above the test's cwd.
         let tmp = tempfile::tempdir().unwrap();
         let sub = tmp.path().join("plain/dir");
         fs::create_dir_all(&sub).unwrap();
-        match find_root(&sub) {
-            None => {} // expected on most hosts
-            Some(root) => assert!(
-                !root.starts_with(tmp.path()),
-                "found .git inside the fixture at {root:?}, but none was created"
-            ),
-        }
+        assert_eq!(find_root(&sub), None);
     }
 
     #[test]

crates/maestro-daemon/src/hooks.rs

@@ -1,53 +1,37 @@
 //! First-start hook auto-install (#106).
 //!
-//! The daemon runs [`auto_install`] once at startup: for every agent maestro
-//! knows how to hook ([`maestro_hooks::Target`]), unless that agent's hook
-//! file already carries exactly what this build ships (and `[hooks]
-//! .auto_install` hasn't opted out — checked by the caller), the same
-//! installer `maestro hooks install` uses writes it. That covers upgrades as
-//! well as first starts: an install from a maestro that had fewer events —
-//! #131 added `UserPromptSubmit` to a hook #106 had already put in everyone's
-//! settings — is rewritten rather than left half-wired. Best-effort: a
-//! failure is warned about and never blocks startup, and one target failing
-//! does not stop the others. The same global hook serves every session on the
-//! machine, so nothing here targets repositories or worktrees.
+//! The daemon runs [`auto_install`] once at startup: unless the user's
+//! `~/.claude/settings.json` already carries exactly what this build ships
+//! (and `[hooks].auto_install` hasn't opted out — checked by the caller), the
+//! same installer `maestro hooks install` uses writes it. That covers
+//! upgrades as well as first starts: an install from a maestro that had fewer
+//! events — #131 added `UserPromptSubmit` to a hook #106 had already put in
+//! everyone's settings — is rewritten rather than left half-wired. Best-effort:
+//! a failure is warned about and never blocks startup. The same global hook
+//! serves every Claude Code session on the machine, so nothing here targets
+//! repositories or worktrees.
 
 use std::path::Path;
 
-use maestro_hooks::Target;
-
-/// Install the activity hook for every [`Target`] under `home_dir`, skipping
-/// any whose install is already current. Returns what happened per target —
-/// an older install being brought up to date is
-/// [`AutoInstallOutcome::Upgraded`], so the log can say so. An unresolvable
-/// home dir (`""`) reports every target as [`AutoInstallOutcome::Skipped`].
-pub fn auto_install(home_dir: &str) -> Vec<(Target, AutoInstallOutcome)> {
-    Target::ALL
-        .iter()
-        .map(|&target| (target, auto_install_target(target, home_dir)))
-        .collect()
-}
-
-fn auto_install_target(target: Target, home_dir: &str) -> AutoInstallOutcome {
+/// Install the Claude Code activity hook for `home_dir` unless the current
+/// one is already there or the home dir is unresolvable (`""`). Returns what
+/// happened; an older install being brought up to date is
+/// [`AutoInstallOutcome::Upgraded`], so the log can say so.
+pub fn auto_install(home_dir: &str) -> AutoInstallOutcome {
     if home_dir.is_empty() {
         return AutoInstallOutcome::Skipped;
     }
-    let home = Path::new(home_dir);
-    let settings = target.settings_path(home);
-    let script = maestro_hooks::script_path(home);
-    if maestro_hooks::is_current(target, &settings, &script) {
+    let settings = maestro_hooks::settings_path(Path::new(home_dir));
+    let script = maestro_hooks::script_path(Path::new(home_dir));
+    if maestro_hooks::is_current(&settings, &script) {
         return AutoInstallOutcome::AlreadyPresent;
     }
     let stale = maestro_hooks::is_installed(&settings);
-    match maestro_hooks::install_target(target, home) {
+    match maestro_hooks::install_for_home(Path::new(home_dir)) {
         Ok(_) if stale => AutoInstallOutcome::Upgraded,
         Ok(_) => AutoInstallOutcome::Installed,
         Err(e) => {
-            tracing::warn!(
-                target = target.label(),
-                error = %e,
-                "hooks auto-install failed (non-fatal)"
-            );
+            tracing::warn!(error = %e, "hooks auto-install failed (non-fatal)");
             AutoInstallOutcome::Failed
         }
     }
@@ -68,50 +52,15 @@ pub enum AutoInstallOutcome {
 mod tests {
     use super::*;
 
-    /// The outcome recorded for one target.
-    fn outcome(outcomes: &[(Target, AutoInstallOutcome)], target: Target) -> AutoInstallOutcome {
-        outcomes
-            .iter()
-            .find(|(t, _)| *t == target)
-            .map(|(_, o)| *o)
-            .expect("every target is reported")
-    }
-
     /// Everything happens under a temp `$HOME`; the developer's own
-    /// `~/.claude/settings.json` and `~/.codex/hooks.json` are never read or
-    /// written.
+    /// `~/.claude/settings.json` is never read or written.
     #[test]
     fn installs_when_settings_carry_no_maestro_hook() {
         let dir = tempfile::tempdir().unwrap();
-        let outcomes = auto_install(dir.path().to_str().unwrap());
-        for target in Target::ALL {
-            assert_eq!(
-                outcome(&outcomes, target),
-                AutoInstallOutcome::Installed,
-                "{}",
-                target.label()
-            );
-            assert!(maestro_hooks::is_installed(
-                &target.settings_path(dir.path())
-            ));
-        }
-    }
-
-    /// Every agent maestro knows about is hooked, not just Claude Code: a
-    /// codex session reports activity and its first prompt the same way.
-    #[test]
-    fn codex_gets_its_own_hook_file() {
-        let dir = tempfile::tempdir().unwrap();
-        auto_install(dir.path().to_str().unwrap());
-        let hooks = dir.path().join(".codex/hooks.json");
-        let root: serde_json::Value =
-            serde_json::from_str(&std::fs::read_to_string(&hooks).unwrap()).unwrap();
-        let events = root["hooks"].as_object().unwrap();
-        assert!(events.contains_key("PermissionRequest"));
-        assert!(
-            !events.contains_key("Notification"),
-            "codex has no Notification"
-        );
+        let outcome = auto_install(dir.path().to_str().unwrap());
+        assert_eq!(outcome, AutoInstallOutcome::Installed);
+        let settings = dir.path().join(".claude/settings.json");
+        assert!(maestro_hooks::is_installed(&settings));
     }
 
     #[test]
@@ -120,22 +69,14 @@ mod tests {
         let home = dir.path().to_str().unwrap();
         auto_install(home);
         // A current install is left exactly as it is.
-        let before: Vec<String> = Target::ALL
-            .iter()
-            .map(|t| std::fs::read_to_string(t.settings_path(dir.path())).unwrap())
-            .collect();
-        let outcomes = auto_install(home);
-        for (i, target) in Target::ALL.iter().enumerate() {
-            assert_eq!(
-                outcome(&outcomes, *target),
-                AutoInstallOutcome::AlreadyPresent
-            );
-            assert_eq!(
-                before[i],
-                std::fs::read_to_string(target.settings_path(dir.path())).unwrap(),
-                "already-installed settings must not be rewritten"
-            );
-        }
+        let settings = dir.path().join(".claude/settings.json");
+        let before = std::fs::read_to_string(&settings).unwrap();
+        assert_eq!(auto_install(home), AutoInstallOutcome::AlreadyPresent);
+        assert_eq!(
+            before,
+            std::fs::read_to_string(&settings).unwrap(),
+            "already-installed settings must not be rewritten"
+        );
     }
 
     /// An install from an older maestro — present, but missing an event this
@@ -146,7 +87,7 @@ mod tests {
         let dir = tempfile::tempdir().unwrap();
         let home = dir.path().to_str().unwrap();
         auto_install(home);
-        let settings = Target::ClaudeCode.settings_path(dir.path());
+        let settings = dir.path().join(".claude/settings.json");
         let script = maestro_hooks::script_path(dir.path());
 
         let mut root: serde_json::Value =
@@ -155,23 +96,12 @@ mod tests {
         std::fs::write(&settings, serde_json::to_string_pretty(&root).unwrap()).unwrap();
         std::fs::write(&script, "#!/bin/sh\nexit 0\n").unwrap();
 
-        let outcomes = auto_install(home);
-        assert_eq!(
-            outcome(&outcomes, Target::ClaudeCode),
-            AutoInstallOutcome::Upgraded
-        );
-        assert!(maestro_hooks::is_current(
-            Target::ClaudeCode,
-            &settings,
-            &script
-        ));
+        assert_eq!(auto_install(home), AutoInstallOutcome::Upgraded);
+        assert!(maestro_hooks::is_current(&settings, &script));
     }
 
     #[test]
     fn unresolvable_home_is_skipped() {
-        let outcomes = auto_install("");
-        for target in Target::ALL {
-            assert_eq!(outcome(&outcomes, target), AutoInstallOutcome::Skipped);
-        }
+        assert_eq!(auto_install(""), AutoInstallOutcome::Skipped);
     }
 }

crates/maestro-daemon/src/lib.rs

@@ -12,6 +12,7 @@ pub mod attach;
 /// Naming a session after its first prompt (#131).
 #[cfg(feature = "haiku-autoname")]
 pub mod autoname;
+pub mod boot_id;
 pub mod branches;
 pub mod cli;
 pub mod config;
@@ -21,10 +22,11 @@ pub mod hooks;
 pub mod local_api;
 pub mod panes;
 pub mod proc;
-pub mod projection;
 pub mod projects;
 pub mod pty;
 pub mod release;
+pub mod resume;
+pub mod scrollback;
 pub mod session;
 pub mod sidecar;
 pub mod spawn_history;

crates/maestro-daemon/src/local_api.rs

@@ -12,8 +12,7 @@
 
 use std::sync::Arc;
 
-use axum::body::Bytes;
-use axum::extract::{DefaultBodyLimit, Path, Query, State};
+use axum::extract::{Path, Query, State};
 use axum::http::StatusCode;
 use axum::response::{IntoResponse, Response};
 use axum::routing::{any, delete, get, post};
@@ -22,14 +21,12 @@ use maestro_config::SpawnPreset;
 use maestro_protocol::{
     routes, ApiError, CatalogEvent, CreateSessionRequest, DaemonInfo, GitRoot, NameBatch,
     RenameSessionRequest, ReportActivityRequest, SendInputRequest, Session, SetFocusRequest,
-    StructuredApprovalDecision, StructuredConfigRequest, StructuredEvent, StructuredPromptRequest,
     PROTOCOL_VERSION,
 };
 use serde::Deserialize;
 use uuid::Uuid;
 
-use crate::session::{QueueAcpPrompt, SessionError, SessionManager, SetAcpConfig};
-use crate::sidecar::EventCursor;
+use crate::session::SessionManager;
 
 #[derive(Debug, Clone)]
 pub struct LocalApiState {
@@ -55,6 +52,7 @@ pub fn router(state: LocalApiState) -> Router {
         .route(routes::patterns::SESSION_ACTIVITY, post(report_activity))
         .route(routes::patterns::SESSION_INPUT, post(send_input))
         .route(routes::patterns::SESSION_FOCUS, post(set_focus))
+        .route(routes::patterns::SESSION_RESUME, post(resume_session))
         .route(
             routes::patterns::SESSION,
             delete(kill_session).patch(rename_session),
@@ -67,20 +65,7 @@ pub fn router(state: LocalApiState) -> Router {
         .route(routes::NAMES, get(names))
         .route(routes::INFO, get(daemon_info))
         .route(routes::EVENTS, any(events_ws))
-        .route(routes::patterns::ATTACH, any(attach_ws))
-        .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(
-            routes::patterns::STRUCTURED_APPROVAL,
-            post(structured_approval),
-        );
+        .route(routes::patterns::ATTACH, any(attach_ws));
     #[cfg(feature = "haiku-autoname")]
     {
         router = router.route(routes::patterns::SESSION_PROMPT, post(session_prompt));
@@ -180,14 +165,15 @@ fn dir_error_status(code: &str) -> StatusCode {
 fn session_error_status(code: &str) -> StatusCode {
     match code {
         "not_found" => StatusCode::NOT_FOUND,
-        "invalid_env" | "bad_request" => StatusCode::BAD_REQUEST,
+        "invalid_env" => StatusCode::BAD_REQUEST,
         // A guard refusal is the daemon doing its job, not a failure (#79).
         "kill_guarded" => StatusCode::CONFLICT,
         // The session outlived its pane: nothing to type into, and nothing
         // the daemon can do about it.
         "not_running" => StatusCode::CONFLICT,
-        "not_terminal" => StatusCode::CONFLICT,
-        "shutting_down" => StatusCode::SERVICE_UNAVAILABLE,
+        // Resume refusals (#166): the session exists and the request was
+        // well-formed, it just cannot be brought back in this state.
+        "already_running" | "cwd_missing" => StatusCode::CONFLICT,
         _ => StatusCode::BAD_GATEWAY,
     }
 }
@@ -315,16 +301,21 @@ async fn rename_session(
     }
 }
 
-/// `POST /api/sessions/:id/activity` (#105): an agent reports a terminal
-/// session's state. Structured sessions acknowledge and ignore these reports
-/// because their activity comes from ACP. Unknown session is 404; an unknown
-/// state value is rejected by the JSON decoder (422). Answers `204 No Content`.
+/// `POST /api/sessions/:id/activity` (#105): an agent reports its own state.
+/// The report holds above the daemon's inference for a TTL, then inference
+/// resumes — an agent that dies mid-run cannot pin its session at `Error`
+/// forever. Unknown session is 404; an unknown state value is rejected by the
+/// JSON decoder (422) rather than coerced. Answers `204 No Content`.
 async fn report_activity(
     State(s): State<LocalApiState>,
     Path(id): Path<Uuid>,
     Json(body): Json<ReportActivityRequest>,
 ) -> Response {
-    match s.manager.report_activity(id, body.state, body.detail).await {
+    match s
+        .manager
+        .report_activity(id, body.state, body.detail, body.session_id)
+        .await
+    {
         Ok(()) => StatusCode::NO_CONTENT.into_response(),
         Err(e) => {
             let info = e.to_error_info();
@@ -381,202 +372,31 @@ async fn set_focus(
     }
 }
 
+/// `POST /api/sessions/:id/resume` (#166): respawn a session that has no pane
+/// under its own id and sidecar, so its name, `created_at`, env and worktree
+/// ownership survive. Answers with the updated session, which also goes out as
+/// `SessionUpdated` to every events subscriber.
+///
+/// Refused with `409` when the session is already running or its `cwd` is
+/// gone; `404` when there is no such session.
+async fn resume_session(State(s): State<LocalApiState>, Path(id): Path<Uuid>) -> Response {
+    match s.manager.resume(id, &s.presets).await {
+        Ok(session) => (StatusCode::OK, Json(session)).into_response(),
+        Err(e) => {
+            let info = e.to_error_info();
+            error_response(
+                session_error_status(&info.code),
+                info.code.as_str(),
+                info.message.as_str(),
+            )
+        }
+    }
+}
+
 fn error_response(status: StatusCode, code: &str, message: &str) -> Response {
     (status, Json(ApiError::new(code, message))).into_response()
 }
 
-#[derive(Debug, Deserialize)]
-struct ReplayQuery {
-    since: Option<u64>,
-    before: Option<u64>,
-    limit: Option<usize>,
-}
-
-const MAX_STRUCTURED_REPLAY_LIMIT: usize = 500;
-
-async fn structured_replay(
-    State(s): State<LocalApiState>,
-    Path(id): Path<Uuid>,
-    Query(query): Query<ReplayQuery>,
-) -> Response {
-    if query.since.is_some() && query.before.is_some() {
-        return error_response(
-            StatusCode::BAD_REQUEST,
-            "invalid_cursor",
-            "use either since or before, not both",
-        );
-    }
-    let cursor = match query.before {
-        Some(before) => EventCursor::Before(Some(before)),
-        None => EventCursor::Since(query.since.unwrap_or(0)),
-    };
-    match s
-        .manager
-        .read_acp_projection_replay(
-            id,
-            cursor,
-            query
-                .limit
-                .unwrap_or(100)
-                .clamp(1, MAX_STRUCTURED_REPLAY_LIMIT),
-        )
-        .await
-    {
-        Ok(Some(events)) => Json(events).into_response(),
-        // A terminal session, or a structured session whose adapter is no
-        // longer live, cannot provide a coherent replay continuation.
-        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)
-        }
-    }
-}
-
-#[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>,
-    Json(body): Json<StructuredPromptRequest>,
-) -> Response {
-    match s.manager.queue_acp_prompt(id, body.prompt, None).await {
-        Ok(QueueAcpPrompt::Dispatched) => StatusCode::NO_CONTENT.into_response(),
-        Ok(QueueAcpPrompt::Queued) => StatusCode::ACCEPTED.into_response(),
-        Ok(QueueAcpPrompt::Full) => error_response(
-            StatusCode::TOO_MANY_REQUESTS,
-            "queue_full",
-            "the prompt queue has reached its capacity",
-        ),
-        Ok(QueueAcpPrompt::Unavailable) => error_response(
-            StatusCode::CONFLICT,
-            "not_structured",
-            "session is not a live structured session",
-        ),
-        Ok(QueueAcpPrompt::Failed(message)) => {
-            error_response(StatusCode::BAD_GATEWAY, "acp_prompt_failed", &message)
-        }
-        Err(e) => {
-            let info = e.to_error_info();
-            error_response(session_error_status(&info.code), &info.code, &info.message)
-        }
-    }
-}
-
-async fn structured_cancel(State(s): State<LocalApiState>, Path(id): Path<Uuid>) -> Response {
-    match s.manager.cancel_acp_turn(id).await {
-        Ok(true) => StatusCode::NO_CONTENT.into_response(),
-        Ok(false) => 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_config(
-    State(s): State<LocalApiState>,
-    Path(id): Path<Uuid>,
-    Json(body): Json<StructuredConfigRequest>,
-) -> Response {
-    match s
-        .manager
-        .set_acp_config(id, body.config_id, body.value)
-        .await
-    {
-        Ok(SetAcpConfig::Updated) => StatusCode::NO_CONTENT.into_response(),
-        Ok(SetAcpConfig::InvalidValue) => error_response(
-            StatusCode::BAD_REQUEST,
-            "invalid_config_value",
-            "configuration values must be strings or booleans",
-        ),
-        Ok(SetAcpConfig::Unavailable) => error_response(
-            StatusCode::CONFLICT,
-            "not_structured",
-            "session is not a live structured session",
-        ),
-        Ok(SetAcpConfig::Failed(message)) => {
-            error_response(StatusCode::BAD_GATEWAY, "acp_config_failed", &message)
-        }
-        Err(e) => {
-            let info = e.to_error_info();
-            error_response(session_error_status(&info.code), &info.code, &info.message)
-        }
-    }
-}
-
-async fn structured_approval(
-    State(s): State<LocalApiState>,
-    Path((id, nonce)): Path<(Uuid, String)>,
-    Json(decision): Json<StructuredApprovalDecision>,
-) -> Response {
-    let decision = match decision {
-        StructuredApprovalDecision::AllowOnce => crate::session::ApprovalDecision::AllowOnce,
-        StructuredApprovalDecision::AllowForSession => {
-            crate::session::ApprovalDecision::AllowForSession
-        }
-        StructuredApprovalDecision::Deny => crate::session::ApprovalDecision::Deny,
-    };
-    match s.manager.resolve_acp_approval(id, &nonce, decision).await {
-        Ok(Some(())) => StatusCode::NO_CONTENT.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)
-        }
-    }
-}
-
 /// Convenience constructor — pulls the bits `LocalApiState` needs from
 /// `DaemonConfig` so callers don't have to assemble it by hand. The project
 /// scanner starts with its cache cold; wire
@@ -614,23 +434,22 @@ async fn attach_ws(
     State(s): State<LocalApiState>,
     ws: axum::extract::WebSocketUpgrade,
 ) -> Result<Response, Response> {
-    let (replay, rx) = match s.manager.subscribe_pty_with_replay(id).await {
-        Ok(subscription) => subscription,
-        Err(SessionError::NotFound(_)) => {
+    let Some((replay, rx)) = s.manager.subscribe_pty_with_replay(id).await else {
+        // #166: a session the daemon knows but has no bridge for — a dormant
+        // one — is not missing, it is not running. Reporting it as unknown
+        // left the client unable to tell "gone" from "resumable".
+        if s.manager.has(id).await {
             return Err(error_response(
-                StatusCode::NOT_FOUND,
-                "unknown_session",
-                "no such session on this daemon",
-            ));
-        }
-        Err(error) => {
-            let info = error.to_error_info();
-            return Err(error_response(
-                session_error_status(&info.code),
-                &info.code,
-                &info.message,
+                StatusCode::CONFLICT,
+                "not_attachable",
+                "session has no live pane; resume it first",
             ));
         }
+        return Err(error_response(
+            StatusCode::NOT_FOUND,
+            "unknown_session",
+            "no such session on this daemon",
+        ));
     };
     let manager = s.manager.clone();
     Ok(ws.on_upgrade(move |socket| async move {
@@ -638,75 +457,6 @@ async fn attach_ws(
     }))
 }
 
-#[allow(clippy::result_large_err)]
-async fn structured_ws(
-    Path(id): Path<Uuid>,
-    State(s): State<LocalApiState>,
-    ws: axum::extract::WebSocketUpgrade,
-) -> Result<Response, Response> {
-    let Some((snapshot, state, rx)) = s
-        .manager
-        .subscribe_acp_projection(id, EventCursor::Since(0))
-        .await
-        .map_err(|e| {
-            let info = e.to_error_info();
-            error_response(session_error_status(&info.code), &info.code, &info.message)
-        })?
-    else {
-        return Err(error_response(
-            StatusCode::CONFLICT,
-            "not_structured",
-            "session is not a live structured session",
-        ));
-    };
-    Ok(ws.on_upgrade(move |socket| async move {
-        let _ = pump_structured(socket, snapshot, state, rx).await;
-    }))
-}
-
-async fn pump_structured(
-    socket: axum::extract::ws::WebSocket,
-    snapshot: maestro_protocol::TranscriptSnapshot,
-    state: maestro_protocol::ReducedState,
-    mut rx: tokio::sync::broadcast::Receiver<crate::projection::ProjectionUpdate>,
-) -> Result<(), axum::Error> {
-    use axum::extract::ws::Message;
-    use futures_util::{SinkExt, StreamExt};
-
-    let (mut sink, mut stream) = socket.split();
-    for event in [
-        StructuredEvent::TranscriptSnapshot { snapshot },
-        StructuredEvent::ReducedState { state },
-    ] {
-        if sink
-            .send(Message::Text(
-                serde_json::to_string(&event).expect("structured event encode"),
-            ))
-            .await
-            .is_err()
-        {
-            return Ok(());
-        }
-    }
-    loop {
-        tokio::select! {
-            update = rx.recv() => match update {
-                Ok(update) => {
-                    let event = StructuredEvent::ProjectionUpdate { transcript: update.transcript, state: update.state };
-                    if sink.send(Message::Text(serde_json::to_string(&event).expect("structured event encode"))).await.is_err() { break; }
-                }
-                Err(tokio::sync::broadcast::error::RecvError::Lagged(_)) => break,
-                Err(tokio::sync::broadcast::error::RecvError::Closed) => break,
-            },
-            frame = stream.next() => match frame {
-                None | Some(Err(_)) | Some(Ok(Message::Close(_))) => break,
-                Some(Ok(_)) => {},
-            },
-        }
-    }
-    Ok(())
-}
-
 // ---------------------------------------------------------------------------
 // WS /api/events — live catalog deltas for browser/TUI subscribers (NAP-248)
 // ---------------------------------------------------------------------------

crates/maestro-daemon/src/pty.rs

@@ -21,6 +21,11 @@
 //!   one-shot prefix before joining the live broadcast, so attaching to an
 //!   idle session immediately shows the last screenful instead of a blank
 //!   terminal.
+//! - #171: a bridge can be started with scrollback restored from disk — what
+//!   the session printed before the daemon (or the host) went away. Those
+//!   bytes are handed to subscribers ahead of the live ones until the ring
+//!   has a full budget of new output of its own, at which point the restored
+//!   history is older than anything the budget covers and is dropped.
 
 use std::collections::VecDeque;
 use std::ffi::CString;
@@ -58,6 +63,10 @@ const READ_BUF_BYTES: usize = 4096;
 #[derive(Debug)]
 pub struct PtyBridge {
     fifo_path: PathBuf,
+    /// Scrollback from a previous life of this session (#171), replayed
+    /// ahead of the ring. Empty for a fresh spawn. Never appended to, so it
+    /// can never duplicate a byte the ring also holds.
+    restored: Vec<u8>,
     /// `None` once [`Self::seal`] has run: live subscribers see the channel
     /// close, but the replay buffer stays readable.
     sender: Option<broadcast::Sender<Vec<u8>>>,
@@ -79,6 +88,21 @@ impl PtyBridge {
     /// Variant that lets the caller pick a custom replay-buffer cap (bytes).
     /// Pass `0` to disable replay (subscribers see only live bytes).
     pub async fn start_with_replay(fifo_path: PathBuf, replay_bytes: usize) -> io::Result<Self> {
+        Self::start_restoring(fifo_path, replay_bytes, Vec::new()).await
+    }
+
+    /// As [`Self::start_with_replay`], seeded with `restored` scrollback read
+    /// back from disk (#171). The seed is truncated to the same
+    /// `replay_bytes` budget the ring uses — there is one budget here, not
+    /// two — and is dropped entirely when replay is disabled.
+    pub async fn start_restoring(
+        fifo_path: PathBuf,
+        replay_bytes: usize,
+        mut restored: Vec<u8>,
+    ) -> io::Result<Self> {
+        if restored.len() > replay_bytes {
+            restored.drain(..restored.len() - replay_bytes);
+        }
         if let Some(parent) = fifo_path.parent() {
             tokio::fs::create_dir_all(parent).await?;
         }
@@ -102,6 +126,7 @@ impl PtyBridge {
         });
         Ok(Self {
             fifo_path,
+            restored,
             sender: Some(sender),
             replay,
             last_activity,
@@ -155,7 +180,8 @@ impl PtyBridge {
         F: FnOnce() -> Option<Vec<u8>>,
     {
         let guard = self.replay.lock_for_snapshot();
-        let snapshot = capture().unwrap_or_else(|| guard.snapshot());
+        let live = capture().unwrap_or_else(|| guard.snapshot());
+        let snapshot = guard.with_restored_prefix(&self.restored, live);
         let rx = match &self.sender {
             Some(tx) => tx.subscribe(),
             // Sealed: hand back the scrollback plus a receiver that is already
@@ -171,6 +197,25 @@ impl PtyBridge {
         (snapshot, rx)
     }
 
+    /// Everything worth persisting for a later life of this session (#171):
+    /// the restored scrollback and the ring, trimmed together to the replay
+    /// budget so the file on disk is never bigger than the ring it mirrors.
+    pub fn scrollback(&self) -> Vec<u8> {
+        let guard = self.replay.lock_for_snapshot();
+        guard.with_restored_prefix(&self.restored, guard.snapshot())
+    }
+
+    /// Total bytes this bridge has appended to its ring. The scrollback flush
+    /// pass compares it against what it last wrote, so an idle session costs
+    /// no disk writes at all.
+    pub fn bytes_seen(&self) -> u64 {
+        self.replay
+            .inner
+            .lock()
+            .expect("ReplayBuffer poisoned")
+            .seen
+    }
+
     /// Stop reading and close the live stream, keeping the replay buffer.
     ///
     /// Attached clients see the channel close — without that a `maestro attach`
@@ -201,6 +246,8 @@ struct ReplayBuffer {
 struct ReplayInner {
     buf: VecDeque<u8>,
     cap: usize,
+    /// Bytes ever appended, not bytes held — the ring evicts, this does not.
+    seen: u64,
 }
 
 impl ReplayBuffer {
@@ -209,6 +256,7 @@ impl ReplayBuffer {
             inner: Arc::new(Mutex::new(ReplayInner {
                 buf: VecDeque::with_capacity(cap.min(READ_BUF_BYTES * 2)),
                 cap,
+                seen: 0,
             })),
         }
     }
@@ -225,6 +273,7 @@ impl ReplayBuffer {
         // If the incoming chunk alone exceeds the cap, take only its tail —
         // anything in the buffer would be evicted before this finishes anyway.
         let take_from = bytes.len().saturating_sub(s.cap);
+        s.seen += bytes.len() as u64;
         let bytes = &bytes[take_from..];
         s.buf.extend(bytes);
         while s.buf.len() > s.cap {
@@ -247,6 +296,24 @@ struct ReplayGuard<'a> {
 }
 
 impl ReplayGuard<'_> {
+    /// `live` with the restored scrollback (#171) in front of it, while the
+    /// ring still holds less than a full budget of its own output. Once it
+    /// holds a full budget, everything restored is older than what the
+    /// budget covers, so it is dropped rather than kept forever.
+    fn with_restored_prefix(&self, restored: &[u8], live: Vec<u8>) -> Vec<u8> {
+        let cap = self.inner.cap;
+        let held = self.inner.buf.len();
+        if restored.is_empty() || cap == 0 || held >= cap {
+            return live;
+        }
+        let keep = cap - held;
+        let start = restored.len().saturating_sub(keep);
+        let mut out = Vec::with_capacity((restored.len() - start) + live.len());
+        out.extend_from_slice(&restored[start..]);
+        out.extend_from_slice(&live);
+        out
+    }
+
     fn snapshot(&self) -> Vec<u8> {
         let (a, b) = self.inner.buf.as_slices();
         let mut out = Vec::with_capacity(a.len() + b.len());
@@ -292,6 +359,7 @@ async fn run_reader(
                 // never both, never neither.
                 let mut s = replay.inner.lock().expect("ReplayBuffer poisoned");
                 if s.cap > 0 {
+                    s.seen += n as u64;
                     let take_from = n.saturating_sub(s.cap);
                     s.buf.extend(&buf[take_from..n]);
                     while s.buf.len() > s.cap {
@@ -345,6 +413,80 @@ fn shell_quote(s: &str) -> String {
 mod tests {
     use super::*;
 
+    async fn bridge(cap: usize, restored: &[u8]) -> (tempfile::TempDir, PtyBridge) {
+        let dir = tempfile::TempDir::new().expect("tempdir");
+        let bridge =
+            PtyBridge::start_restoring(dir.path().join("pty.fifo"), cap, restored.to_vec())
+                .await
+                .expect("start bridge");
+        (dir, bridge)
+    }
+
+    /// Feed the bridge through its own FIFO and wait for the reader to have
+    /// taken the bytes, so the ring state is deterministic.
+    async fn feed(bridge: &PtyBridge, bytes: &[u8]) {
+        use std::io::Write;
+        let before = bridge.bytes_seen();
+        let mut f = std::fs::OpenOptions::new()
+            .write(true)
+            .open(bridge.fifo_path())
+            .expect("open fifo for write");
+        f.write_all(bytes).expect("write fifo");
+        drop(f);
+        for _ in 0..400 {
+            if bridge.bytes_seen() >= before + bytes.len() as u64 {
+                return;
+            }
+            tokio::time::sleep(std::time::Duration::from_millis(5)).await;
+        }
+        panic!("bridge never read the bytes written to its fifo");
+    }
+
+    #[tokio::test]
+    async fn restored_scrollback_is_replayed_ahead_of_live_bytes() {
+        let (_dir, bridge) = bridge(64, b"before the reboot\n").await;
+        feed(&bridge, b"after\n").await;
+        let (replay, _rx) = bridge.subscribe_with_replay();
+        assert_eq!(replay, b"before the reboot\nafter\n");
+    }
+
+    #[tokio::test]
+    async fn restored_scrollback_is_trimmed_to_the_replay_budget() {
+        let (_dir, bridge) = bridge(4, b"abcdefghij").await;
+        let (replay, _rx) = bridge.subscribe_with_replay();
+        assert_eq!(replay, b"ghij");
+    }
+
+    #[tokio::test]
+    async fn restored_scrollback_yields_once_the_ring_holds_a_full_budget() {
+        let (_dir, bridge) = bridge(4, b"old!").await;
+        feed(&bridge, b"ab").await;
+        let (replay, _rx) = bridge.subscribe_with_replay();
+        assert_eq!(replay, b"d!ab", "prefix plus ring stays inside the budget");
+        feed(&bridge, b"cd").await;
+        let (replay, _rx) = bridge.subscribe_with_replay();
+        assert_eq!(
+            replay, b"abcd",
+            "restored history is now older than the budget"
+        );
+    }
+
+    #[tokio::test]
+    async fn scrollback_carries_the_restored_prefix_and_the_ring() {
+        let (_dir, bridge) = bridge(8, b"old").await;
+        feed(&bridge, b"new").await;
+        assert_eq!(bridge.scrollback(), b"oldnew");
+        assert_eq!(bridge.bytes_seen(), 3);
+    }
+
+    #[tokio::test]
+    async fn no_replay_budget_means_no_restored_scrollback() {
+        let (_dir, bridge) = bridge(0, b"old").await;
+        let (replay, _rx) = bridge.subscribe_with_replay();
+        assert!(replay.is_empty());
+        assert!(bridge.scrollback().is_empty());
+    }
+
     #[test]
     fn replay_buffer_keeps_last_cap_bytes() {
         let r = ReplayBuffer::new(4);

crates/maestro-daemon/src/resume.rs

@@ -0,0 +1,99 @@
+//! Choosing the command a resumed session comes back on (#166).
+//!
+//! A session records the command it was spawned with. Bringing it back means
+//! running that preset's `resume_command` (#165) instead, so an agent picks up
+//! its old conversation rather than starting a fresh one. Everything else
+//! about the session — id, sidecar, name, `created_at`, env, worktree — is
+//! untouched, so only the command is decided here.
+
+use maestro_protocol::{Session, SpawnPreset};
+
+/// The command to respawn `session` with.
+///
+/// The preset is matched on the command the session was spawned with, which is
+/// what the sidecar holds. A session with no matching preset, a preset with no
+/// `resume_command`, or a `resume_command` needing an agent session id the
+/// session never reported all fall back to the original command: respawning
+/// what the operator asked for is always honest, where a half-filled resume
+/// template is not.
+pub fn resume_command(session: &Session, presets: &[SpawnPreset]) -> String {
+    presets
+        .iter()
+        .find(|p| p.command == session.command)
+        .and_then(|p| p.resume_command_for(session.agent_session_id.as_deref()))
+        .unwrap_or_else(|| session.command.clone())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::collections::HashMap;
+
+    fn presets() -> Vec<SpawnPreset> {
+        vec![
+            SpawnPreset {
+                id: "claude".into(),
+                label: "Claude".into(),
+                command: "claude".into(),
+                resume_command: Some("claude --resume {agent_session}".into()),
+            },
+            SpawnPreset {
+                id: "zsh".into(),
+                label: "Shell".into(),
+                command: "zsh".into(),
+                resume_command: None,
+            },
+        ]
+    }
+
+    fn session(command: &str, agent_session_id: Option<&str>) -> Session {
+        Session {
+            id: uuid::Uuid::new_v4(),
+            cwd: "/tmp".into(),
+            command: command.into(),
+            env: HashMap::new(),
+            metadata: HashMap::new(),
+            worktree: None,
+            status: maestro_protocol::SessionStatus::Dormant,
+            created_at: chrono::Utc::now(),
+            foreground: None,
+            activity: maestro_protocol::ActivityState::Idle,
+            activity_detail: None,
+            last_activity_at: chrono::Utc::now(),
+            activity_since: chrono::Utc::now(),
+            current_cwd: None,
+            blocked_work: None,
+            last_focused_at: None,
+            agent_session_id: agent_session_id.map(str::to_string),
+        }
+    }
+
+    #[test]
+    fn uses_the_matching_presets_resume_command() {
+        assert_eq!(
+            resume_command(&session("claude", Some("conv-7")), &presets()),
+            "claude --resume conv-7"
+        );
+    }
+
+    #[test]
+    fn falls_back_when_the_agent_session_id_is_unknown() {
+        assert_eq!(
+            resume_command(&session("claude", None), &presets()),
+            "claude"
+        );
+    }
+
+    #[test]
+    fn falls_back_for_a_preset_without_a_resume_command() {
+        assert_eq!(resume_command(&session("zsh", None), &presets()), "zsh");
+    }
+
+    #[test]
+    fn falls_back_when_no_preset_matches() {
+        assert_eq!(
+            resume_command(&session("bash --noprofile", Some("conv-7")), &presets()),
+            "bash --noprofile"
+        );
+    }
+}

crates/maestro-daemon/src/scrollback.rs

@@ -0,0 +1,148 @@
+//! Persisted PTY scrollback (#171).
+//!
+//! The PTY replay ring lives in memory, so everything a session printed is
+//! gone the moment the daemon process is. A resumed session then opens on a
+//! blank pane: the agent's conversation is back, but the terminal history the
+//! operator was reading is not.
+//!
+//! This store mirrors each bridge's ring to `<state_dir>/scrollback/<id>.bin`,
+//! and hands it back when a session gets a new bridge — on resume, and on the
+//! recovery pass that re-adopts a session tmux still holds. The file is
+//! capped at the same `replay_bytes` budget the in-memory ring uses, so disk
+//! cost is bounded by the same number the operator already configures.
+//!
+//! Nothing here is allowed to fail a resume. The payload is raw PTY bytes
+//! with no framing to be corrupt, and a file that is missing, unreadable or
+//! oversized degrades to an empty (or truncated) pane rather than an error.
+
+use std::io;
+use std::path::{Path, PathBuf};
+
+use uuid::Uuid;
+
+/// Filesystem-backed scrollback store, rooted at a directory.
+#[derive(Debug, Clone)]
+pub struct ScrollbackStore {
+    dir: PathBuf,
+}
+
+impl ScrollbackStore {
+    pub fn new(dir: impl Into<PathBuf>) -> Self {
+        Self { dir: dir.into() }
+    }
+
+    pub fn dir(&self) -> &Path {
+        &self.dir
+    }
+
+    pub fn path_for(&self, id: Uuid) -> PathBuf {
+        self.dir.join(format!("{id}.bin"))
+    }
+
+    /// Atomically write `bytes` to `<dir>/<id>.bin`, creating the directory if
+    /// needed. Written through a temp file and renamed, so a reboot in the
+    /// middle of a flush leaves the previous scrollback intact rather than a
+    /// half-file.
+    pub fn write(&self, id: Uuid, bytes: &[u8]) -> io::Result<()> {
+        std::fs::create_dir_all(&self.dir)?;
+        let tmp = self.dir.join(format!("{id}.bin.tmp"));
+        std::fs::write(&tmp, bytes)?;
+        std::fs::rename(&tmp, self.path_for(id))
+    }
+
+    /// The stored scrollback for `id`, capped to the last `budget` bytes.
+    ///
+    /// Never fails: a missing file, an unreadable one, or a `budget` of zero
+    /// all read as "no scrollback", which is exactly the blank pane the
+    /// operator had before this existed.
+    pub fn read(&self, id: Uuid, budget: usize) -> Vec<u8> {
+        if budget == 0 {
+            return Vec::new();
+        }
+        let path = self.path_for(id);
+        let mut bytes = match std::fs::read(&path) {
+            Ok(b) => b,
+            Err(e) if e.kind() == io::ErrorKind::NotFound => return Vec::new(),
+            Err(e) => {
+                tracing::warn!(error = ?e, %id, path = %path.display(), "scrollback: unreadable, resuming with a blank pane");
+                return Vec::new();
+            }
+        };
+        // A file written under a larger budget than this daemon now runs
+        // with keeps its tail, the same end of the stream the ring would.
+        if bytes.len() > budget {
+            bytes.drain(..bytes.len() - budget);
+        }
+        bytes
+    }
+
+    /// Delete the scrollback for `id`. No-op if it is not there.
+    pub fn delete(&self, id: Uuid) -> io::Result<()> {
+        match std::fs::remove_file(self.path_for(id)) {
+            Ok(()) => Ok(()),
+            Err(e) if e.kind() == io::ErrorKind::NotFound => Ok(()),
+            Err(e) => Err(e),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn store() -> (tempfile::TempDir, ScrollbackStore) {
+        let dir = tempfile::TempDir::new().expect("tempdir");
+        let store = ScrollbackStore::new(dir.path().join("scrollback"));
+        (dir, store)
+    }
+
+    #[test]
+    fn round_trips_bytes() {
+        let (_dir, store) = store();
+        let id = Uuid::new_v4();
+        store.write(id, b"hello world").expect("write");
+        assert_eq!(store.read(id, 64), b"hello world");
+    }
+
+    #[test]
+    fn a_missing_file_reads_as_empty() {
+        let (_dir, store) = store();
+        assert!(store.read(Uuid::new_v4(), 64).is_empty());
+    }
+
+    #[test]
+    fn a_file_over_budget_keeps_its_tail() {
+        let (_dir, store) = store();
+        let id = Uuid::new_v4();
+        store.write(id, b"abcdefghij").expect("write");
+        assert_eq!(store.read(id, 4), b"ghij");
+    }
+
+    #[test]
+    fn a_zero_budget_reads_as_empty() {
+        let (_dir, store) = store();
+        let id = Uuid::new_v4();
+        store.write(id, b"abcdefghij").expect("write");
+        assert!(store.read(id, 0).is_empty());
+    }
+
+    #[test]
+    fn delete_removes_the_file_and_tolerates_a_missing_one() {
+        let (_dir, store) = store();
+        let id = Uuid::new_v4();
+        store.write(id, b"gone soon").expect("write");
+        store.delete(id).expect("delete");
+        assert!(!store.path_for(id).exists());
+        store.delete(id).expect("second delete is a no-op");
+    }
+
+    #[test]
+    fn a_second_write_replaces_the_first() {
+        let (_dir, store) = store();
+        let id = Uuid::new_v4();
+        store.write(id, b"first").expect("write");
+        store.write(id, b"second").expect("rewrite");
+        assert_eq!(store.read(id, 64), b"second");
+        assert!(!store.dir().join(format!("{id}.bin.tmp")).exists());
+    }
+}

crates/maestro-daemon/src/sidecar.rs

@@ -5,23 +5,10 @@
 //! original `cwd`, command, env, metadata, etc. Files are deleted on
 //! `KillSession`. Sessions whose sidecar is missing at recovery time are still
 //! advertised but with empty metadata (handled by the caller, not here).
-//!
-//! A structured session (#135) also owns `<id>.events.jsonl` next to its
-//! sidecar: every `session/update` notification and daemon approval row is one
-//! JSON object, appended before it is broadcast. The log is the source of
-//! truth for the transcript; `seq` is the line's 1-based position, so a
-//! client that holds seq `n` asks for [`EventCursor::Since`]`(n)`. A line
-//! that does not parse — including the partial line a hard kill leaves at
-//! the end — keeps its seq and is skipped on read. `delete` removes the log
-//! with the sidecar; `load_all` never reads one as a sidecar.
 
-use std::collections::VecDeque;
-use std::fs::{File, OpenOptions};
-use std::io::{BufRead, BufReader, Read, Seek, SeekFrom, Write};
 use std::path::{Path, PathBuf};
 
-use maestro_acp::schema::SessionNotification;
-use maestro_protocol::{Session, TranscriptRow};
+use maestro_protocol::Session;
 use uuid::Uuid;
 
 #[derive(Debug, thiserror::Error)]
@@ -51,120 +38,6 @@ impl SidecarStore {
         self.dir.join(format!("{id}.json"))
     }
 
-    /// Where the per-session event log lives (#135).
-    pub fn events_path_for(&self, id: Uuid) -> PathBuf {
-        self.dir.join(format!("{id}.events.jsonl"))
-    }
-
-    /// Durable evidence that graceful daemon shutdown ended this structured
-    /// session and the next daemon may resume it.
-    pub fn recovery_path_for(&self, id: Uuid) -> PathBuf {
-        self.dir.join(format!("{id}.recover"))
-    }
-
-    /// Mark `id` as eligible for one structured-session recovery attempt.
-    pub fn mark_for_recovery(&self, id: Uuid) -> Result<(), SidecarError> {
-        std::fs::create_dir_all(&self.dir)?;
-        std::fs::write(self.recovery_path_for(id), [])?;
-        Ok(())
-    }
-
-    /// Consume the graceful-shutdown recovery marker for `id`.
-    pub fn take_recovery_marker(&self, id: Uuid) -> Result<bool, SidecarError> {
-        match std::fs::remove_file(self.recovery_path_for(id)) {
-            Ok(()) => Ok(true),
-            Err(error) if error.kind() == std::io::ErrorKind::NotFound => Ok(false),
-            Err(error) => Err(error.into()),
-        }
-    }
-
-    /// Open the event log for `id` for appending, creating it (and the
-    /// directory) when missing. One handle per live session: the caller
-    /// keeps it for the session's lifetime rather than reopening per
-    /// notification.
-    ///
-    /// A log whose last line has no newline — what a hard kill mid-write
-    /// leaves behind — is terminated first, so the next append starts a
-    /// fresh line instead of gluing onto the fragment. The fragment keeps
-    /// the seq of its line and reads as malformed.
-    pub fn open_events(&self, id: Uuid) -> Result<EventLog, SidecarError> {
-        std::fs::create_dir_all(&self.dir)?;
-        let mut file = OpenOptions::new()
-            .create(true)
-            .read(true)
-            .append(true)
-            .open(self.events_path_for(id))?;
-        let mut lines = 0u64;
-        let mut last = None;
-        let mut reader = BufReader::new(&mut file);
-        let mut buf = [0u8; 64 * 1024];
-        loop {
-            let n = reader.read(&mut buf)?;
-            if n == 0 {
-                break;
-            }
-            lines += buf[..n].iter().filter(|&&b| b == b'\n').count() as u64;
-            last = Some(buf[n - 1]);
-        }
-        if last.is_some_and(|b| b != b'\n') {
-            file.write_all(b"\n")?;
-            lines += 1;
-        }
-        file.seek(SeekFrom::End(0))?;
-        Ok(EventLog {
-            file: Box::new(file),
-            last_seq: lines,
-        })
-    }
-
-    /// Read events from the log for `id`, at most `limit`, in ascending seq
-    /// order. A missing log is an empty log. Lines that fail to parse are
-    /// skipped but still consume a seq, so cursors stay stable.
-    pub fn read_events(
-        &self,
-        id: Uuid,
-        cursor: EventCursor,
-        limit: usize,
-    ) -> Result<Vec<LoggedEvent>, SidecarError> {
-        let file = match File::open(self.events_path_for(id)) {
-            Ok(f) => f,
-            Err(e) if e.kind() == std::io::ErrorKind::NotFound => return Ok(Vec::new()),
-            Err(e) => return Err(e.into()),
-        };
-        if limit == 0 {
-            return Ok(Vec::new());
-        }
-        let mut out: VecDeque<LoggedEvent> = VecDeque::new();
-        let mut seq = 0u64;
-        for line in BufReader::new(file).split(b'\n') {
-            let line = line?;
-            seq += 1;
-            let keep = match cursor {
-                EventCursor::Since(since) => seq > since,
-                EventCursor::Before(Some(before)) => seq < before,
-                EventCursor::Before(None) => true,
-            };
-            if !keep {
-                if matches!(cursor, EventCursor::Before(Some(_))) {
-                    break;
-                }
-                continue;
-            }
-            let Ok(event) = PersistedEvent::decode(&line) else {
-                continue;
-            };
-            out.push_back(LoggedEvent { seq, event });
-            match cursor {
-                EventCursor::Since(_) if out.len() >= limit => break,
-                EventCursor::Before(_) if out.len() > limit => {
-                    out.pop_front();
-                }
-                _ => {}
-            }
-        }
-        Ok(out.into())
-    }
-
     /// Atomically write `session` to `<dir>/<id>.json`. Creates the directory
     /// if it does not exist.
     pub fn write(&self, session: &Session) -> Result<(), SidecarError> {
@@ -186,13 +59,13 @@ impl SidecarStore {
         }
     }
 
-    /// Delete the sidecar, event log, and recovery marker for `id`. No-op for
-    /// whichever does not exist.
+    /// Delete the sidecar for `id`. No-op if it does not exist.
     pub fn delete(&self, id: Uuid) -> Result<(), SidecarError> {
-        remove_if_present(&self.events_path_for(id))?;
-        remove_if_present(&self.dir.join(format!("{id}.approvals.jsonl")))?;
-        remove_if_present(&self.recovery_path_for(id))?;
-        remove_if_present(&self.path_for(id))
+        match std::fs::remove_file(self.path_for(id)) {
+            Ok(()) => Ok(()),
+            Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(()),
+            Err(e) => Err(e.into()),
+        }
     }
 
     /// Read every sidecar JSON in the directory. Files that fail to parse are
@@ -208,8 +81,6 @@ impl SidecarStore {
         for entry in entries {
             let entry = entry?;
             let path = entry.path();
-            // `.events.jsonl` logs (#135) sit in the same directory and are
-            // never sidecars.
             if path.extension().and_then(|s| s.to_str()) != Some("json") {
                 continue;
             }
@@ -224,425 +95,3 @@ impl SidecarStore {
         Ok(out)
     }
 }
-
-fn remove_if_present(path: &Path) -> Result<(), SidecarError> {
-    match std::fs::remove_file(path) {
-        Ok(()) => Ok(()),
-        Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(()),
-        Err(e) => Err(e.into()),
-    }
-}
-
-/// Which slice of a session's event log to read.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum EventCursor {
-    /// Forward: events with `seq` strictly greater than the cursor, the
-    /// first `limit` of them. `Since(0)` is the whole log from the start.
-    /// What a client catching up after a reconnect asks for.
-    Since(u64),
-    /// Backward: events with `seq` strictly less than the cursor, the last
-    /// `limit` of them, still returned in ascending order. `None` means the
-    /// tail of the log, for a first paint. The next page passes the smallest
-    /// seq it received.
-    Before(Option<u64>),
-}
-
-/// One line of a session's event log.
-#[derive(Debug, Clone, PartialEq)]
-pub struct LoggedEvent {
-    /// 1-based line position in the log; the cursor for [`EventCursor`].
-    pub seq: u64,
-    pub event: PersistedEvent,
-}
-
-/// A single entry in the structured event history.
-///
-/// ACP notifications retain their original JSON representation, so existing
-/// event logs remain readable. Daemon-generated rows use an envelope so they
-/// can share the same cursor sequence without pretending to be ACP traffic.
-#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
-#[serde(tag = "maestroEvent", rename_all = "snake_case")]
-pub enum PersistedEvent {
-    User {
-        row: TranscriptRow,
-    },
-    Approval {
-        row: TranscriptRow,
-    },
-    Turn {
-        row: TranscriptRow,
-    },
-    #[serde(skip)]
-    Notification(Box<SessionNotification>),
-}
-
-impl PersistedEvent {
-    fn decode(line: &[u8]) -> Result<Self, serde_json::Error> {
-        serde_json::from_slice::<SessionNotification>(line)
-            .map(|notification| Self::Notification(Box::new(notification)))
-            .or_else(|_| serde_json::from_slice(line))
-    }
-}
-
-impl From<SessionNotification> for PersistedEvent {
-    fn from(notification: SessionNotification) -> Self {
-        Self::Notification(Box::new(notification))
-    }
-}
-
-impl From<&SessionNotification> for PersistedEvent {
-    fn from(notification: &SessionNotification) -> Self {
-        Self::Notification(Box::new(notification.clone()))
-    }
-}
-
-impl From<&PersistedEvent> for PersistedEvent {
-    fn from(event: &PersistedEvent) -> Self {
-        event.clone()
-    }
-}
-
-/// What an [`EventLog`] appends onto: something seekable by length and
-/// truncatable back to one, so a failed append can be rolled off the end
-/// again. A real [`File`] in production; an in-memory fault double in tests
-/// (#184) — the same [`EventLog::append`] rollback logic runs over both, so
-/// the behavior under test is the production behavior, not a stand-in for
-/// it.
-pub(crate) trait LogSink: Write + Send {
-    fn len(&mut self) -> std::io::Result<u64>;
-    fn truncate(&mut self, len: u64) -> std::io::Result<()>;
-}
-
-impl LogSink for File {
-    fn len(&mut self) -> std::io::Result<u64> {
-        Ok(self.metadata()?.len())
-    }
-
-    fn truncate(&mut self, len: u64) -> std::io::Result<()> {
-        self.set_len(len)
-    }
-}
-
-/// Outcome of a failed [`EventLog::append`].
-#[derive(Debug, thiserror::Error)]
-pub enum AppendError {
-    /// The write or flush failed, but the log was rolled back to exactly the
-    /// byte it was at before the call: `last_seq` and the file agree, and
-    /// this same [`EventLog`] is safe to keep appending to. The event itself
-    /// was never persisted or broadcast.
-    #[error("event append failed, rolled back cleanly: {0}")]
-    Failed(#[source] SidecarError),
-    /// The append failed *and* the rollback did not restore the log to its
-    /// prior length, so the file's line count and `last_seq` may now
-    /// disagree. The caller must not append to this [`EventLog`] again —
-    /// treat the session as dead rather than promise consistency it cannot
-    /// keep.
-    #[error("event append failed ({cause}) and rollback did not restore consistency ({rollback})")]
-    Fatal {
-        cause: SidecarError,
-        rollback: SidecarError,
-    },
-}
-
-impl From<SidecarError> for AppendError {
-    fn from(error: SidecarError) -> Self {
-        AppendError::Failed(error)
-    }
-}
-
-/// An open, append-only handle on one session's event log. Obtained from
-/// [`SidecarStore::open_events`]; held for the session's lifetime.
-pub struct EventLog {
-    file: Box<dyn LogSink>,
-    last_seq: u64,
-}
-
-impl std::fmt::Debug for EventLog {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("EventLog")
-            .field("last_seq", &self.last_seq)
-            .finish_non_exhaustive()
-    }
-}
-
-impl EventLog {
-    /// Wrap an arbitrary sink as an [`EventLog`], for tests that need to
-    /// inject a deterministic append failure (#184) — a partial write, a
-    /// flush that fails after the bytes are already down, or a rollback that
-    /// cannot itself complete.
-    #[cfg(test)]
-    pub(crate) fn for_test(file: impl LogSink + 'static, last_seq: u64) -> Self {
-        Self {
-            file: Box::new(file),
-            last_seq,
-        }
-    }
-
-    /// The seq of the last line, `0` for an empty log.
-    pub fn last_seq(&self) -> u64 {
-        self.last_seq
-    }
-
-    /// Append one notification as a line and return its seq. The line is
-    /// handed to the kernel in a single write before this returns, so a
-    /// caller that broadcasts afterwards never announces an event the log
-    /// would not replay — short of the machine losing power.
-    ///
-    /// A `write_all` that errors partway can leave an unterminated prefix on
-    /// disk; a `flush` that errors after a *complete* `write_all` leaves
-    /// ambiguity about whether that full, well-formed line should count —
-    /// counting it would silently shift every later seq by one, since
-    /// `last_seq` was never bumped for it. Both cases are rolled back to the
-    /// exact pre-append length before returning, so `last_seq` and the file
-    /// never disagree and the same [`EventLog`] can be appended to again
-    /// immediately. If the rollback itself fails, the log's consistency can
-    /// no longer be promised and [`AppendError::Fatal`] is returned instead.
-    pub fn append(&mut self, event: impl Into<PersistedEvent>) -> Result<u64, AppendError> {
-        let event = event.into();
-        let mut line = match &event {
-            PersistedEvent::Notification(notification) => serde_json::to_vec(notification)
-                .map_err(|e| AppendError::from(SidecarError::from(e)))?,
-            _ => {
-                serde_json::to_vec(&event).map_err(|e| AppendError::from(SidecarError::from(e)))?
-            }
-        };
-        line.push(b'\n');
-
-        let pre_len = self
-            .file
-            .len()
-            .map_err(|e| AppendError::from(SidecarError::from(e)))?;
-
-        if let Err(cause) = self.file.write_all(&line) {
-            return Err(self.rollback_after(pre_len, cause));
-        }
-        if let Err(cause) = self.file.flush() {
-            return Err(self.rollback_after(pre_len, cause));
-        }
-
-        self.last_seq += 1;
-        Ok(self.last_seq)
-    }
-
-    fn rollback_after(&mut self, pre_len: u64, cause: std::io::Error) -> AppendError {
-        match self.file.truncate(pre_len) {
-            Ok(()) => AppendError::Failed(SidecarError::Io(cause)),
-            Err(rollback) => AppendError::Fatal {
-                cause: SidecarError::Io(cause),
-                rollback: SidecarError::Io(rollback),
-            },
-        }
-    }
-}
-
-/// Bytes shared between a [`FaultyLogSink`] moved into an [`EventLog`] and
-/// the test that planted it, so the test can inspect what actually ended up
-/// on the "disk" after a fault without reaching into `EventLog`'s private
-/// `file` field.
-#[cfg(test)]
-#[derive(Clone, Default)]
-pub(crate) struct SharedBuf(std::sync::Arc<std::sync::Mutex<Vec<u8>>>);
-
-#[cfg(test)]
-impl SharedBuf {
-    pub(crate) fn snapshot(&self) -> Vec<u8> {
-        self.0.lock().unwrap().clone()
-    }
-}
-
-/// An in-memory [`LogSink`] double that injects one deterministic fault — a
-/// short write, a flush that fails after a full write, or a rollback that
-/// cannot itself complete — then behaves like a healthy sink from then on.
-/// Lets a test prove the *same* [`EventLog`] recovers, rather than one with a
-/// handle swapped in from a healthy disk, which production never does
-/// (#184).
-#[cfg(test)]
-#[derive(Default)]
-pub(crate) struct FaultyLogSink {
-    pub(crate) buf: SharedBuf,
-    /// Accept this many bytes on the next `write` call, then fail the
-    /// *following* call — a short write followed by an error, exactly what
-    /// `write_all` sees from a real fd that dies mid-line. `Write::write`
-    /// must not report an error on a call that made partial progress, so
-    /// the fault is delivered one call later, via `pending_write_error`.
-    pub(crate) fail_write_after: Option<usize>,
-    pub(crate) pending_write_error: bool,
-    pub(crate) fail_flush_once: bool,
-    pub(crate) fail_truncate: bool,
-}
-
-#[cfg(test)]
-impl Write for FaultyLogSink {
-    fn write(&mut self, data: &[u8]) -> std::io::Result<usize> {
-        if self.pending_write_error {
-            self.pending_write_error = false;
-            return Err(std::io::Error::other("fault: write failed mid-line"));
-        }
-        if let Some(allowed) = self.fail_write_after.take() {
-            let allowed = allowed.min(data.len());
-            if allowed == 0 {
-                // No progress was made, so it's fine to report the error
-                // from this same call.
-                return Err(std::io::Error::other("fault: write failed mid-line"));
-            }
-            self.buf
-                .0
-                .lock()
-                .unwrap()
-                .extend_from_slice(&data[..allowed]);
-            self.pending_write_error = true;
-            return Ok(allowed);
-        }
-        self.buf.0.lock().unwrap().extend_from_slice(data);
-        Ok(data.len())
-    }
-
-    fn flush(&mut self) -> std::io::Result<()> {
-        if self.fail_flush_once {
-            self.fail_flush_once = false;
-            return Err(std::io::Error::other(
-                "fault: flush failed after a full write",
-            ));
-        }
-        Ok(())
-    }
-}
-
-#[cfg(test)]
-impl LogSink for FaultyLogSink {
-    fn len(&mut self) -> std::io::Result<u64> {
-        Ok(self.buf.0.lock().unwrap().len() as u64)
-    }
-
-    fn truncate(&mut self, len: u64) -> std::io::Result<()> {
-        if self.fail_truncate {
-            return Err(std::io::Error::other("fault: rollback truncate failed"));
-        }
-        self.buf.0.lock().unwrap().truncate(len as usize);
-        Ok(())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn sample_event(id: &str) -> PersistedEvent {
-        PersistedEvent::Approval {
-            row: TranscriptRow {
-                id: id.to_owned(),
-                kind: maestro_protocol::TranscriptRowKind::Approval,
-                data: serde_json::json!({"tool": "bash"}),
-            },
-        }
-    }
-
-    /// Replays `bytes` as a real on-disk log via the production read path,
-    /// so "live and durable agree" is checked with the same code a
-    /// reconnecting client would hit, not a hand-rolled line splitter.
-    fn replay(bytes: &[u8]) -> Vec<LoggedEvent> {
-        let dir = tempfile::tempdir().unwrap();
-        let store = SidecarStore::new(dir.path());
-        let id = Uuid::new_v4();
-        std::fs::create_dir_all(store.dir()).unwrap();
-        std::fs::write(store.events_path_for(id), bytes).unwrap();
-        store.read_events(id, EventCursor::Since(0), 100).unwrap()
-    }
-
-    #[test]
-    fn append_rolls_back_a_partial_write_and_the_same_instance_recovers() {
-        let buf = SharedBuf::default();
-        let writer = FaultyLogSink {
-            buf: buf.clone(),
-            fail_write_after: Some(5),
-            ..Default::default()
-        };
-        let mut log = EventLog::for_test(writer, 0);
-
-        let err = log.append(sample_event("r1")).unwrap_err();
-        assert!(
-            matches!(err, AppendError::Failed(_)),
-            "a repairable rollback must not be reported fatal"
-        );
-        assert_eq!(log.last_seq(), 0, "cursor must stay put on a failed append");
-        assert!(
-            buf.snapshot().is_empty(),
-            "the partial prefix a failed write_all leaves behind must be truncated away"
-        );
-
-        let seq = log
-            .append(sample_event("r1"))
-            .expect("the same instance must be able to append again after a clean rollback");
-        assert_eq!(seq, 1);
-        assert_eq!(log.last_seq(), 1);
-
-        let bytes = buf.snapshot();
-        assert_eq!(
-            bytes.iter().filter(|&&b| b == b'\n').count(),
-            1,
-            "exactly one well-formed line, not a partial prefix glued to the recovered append"
-        );
-
-        let replayed = replay(&bytes);
-        assert_eq!(replayed.len(), 1);
-        assert_eq!(replayed[0].seq, log.last_seq());
-        let PersistedEvent::Approval { row } = &replayed[0].event else {
-            panic!("approval event");
-        };
-        assert_eq!(row.id, "r1");
-    }
-
-    #[test]
-    fn append_rolls_back_when_flush_fails_after_a_full_write() {
-        let buf = SharedBuf::default();
-        let writer = FaultyLogSink {
-            buf: buf.clone(),
-            fail_flush_once: true,
-            ..Default::default()
-        };
-        let mut log = EventLog::for_test(writer, 0);
-
-        let err = log.append(sample_event("r1")).unwrap_err();
-        assert!(matches!(err, AppendError::Failed(_)));
-        assert_eq!(log.last_seq(), 0);
-        assert!(
-            buf.snapshot().is_empty(),
-            "a full-but-unflushed line must not survive uncounted by last_seq — it would \
-             silently shift every later seq by one"
-        );
-
-        let seq = log
-            .append(sample_event("r1"))
-            .expect("the same instance must recover once flush stops failing");
-        assert_eq!(seq, 1);
-
-        let bytes = buf.snapshot();
-        let replayed = replay(&bytes);
-        assert_eq!(replayed.len(), 1);
-        assert_eq!(replayed[0].seq, log.last_seq());
-    }
-
-    #[test]
-    fn append_reports_fatal_when_rollback_cannot_restore_consistency() {
-        let buf = SharedBuf::default();
-        let writer = FaultyLogSink {
-            buf,
-            fail_write_after: Some(3),
-            fail_truncate: true,
-            ..Default::default()
-        };
-        let mut log = EventLog::for_test(writer, 0);
-
-        let err = log.append(sample_event("r1")).unwrap_err();
-        assert!(
-            matches!(err, AppendError::Fatal { .. }),
-            "an unrepairable rollback must be surfaced as fatal, never silently treated as \
-             a clean recoverable failure"
-        );
-        assert_eq!(
-            log.last_seq(),
-            0,
-            "a fatal append must not advance the cursor either"
-        );
-    }
-}

crates/maestro-daemon/src/worktree.rs

@@ -111,33 +111,16 @@ impl WorktreeManager {
         // Clear registrations whose directory is gone first, so a
         // previously-leaked entry doesn't push this branch to a suffix.
         prune(base_repo)?;
-        let (branch, path) = if create_branch {
-            // Worktrees are commonly abandoned without deleting their branch,
-            // so a random handle can collide with one of its own past runs.
-            // Unlike the `add_existing` arm below, the suffix goes on the
-            // branch name itself — the path is derived from it anyway.
-            let mut candidate = branch.to_string();
-            let mut path = self.target_path(base_repo, &candidate);
-            let mut n = 1;
-            while path.symlink_metadata().is_ok() || branch_exists(base_repo, &candidate) {
-                n += 1;
-                candidate = format!("{branch}-{n}");
-                path = self.target_path(base_repo, &candidate);
-            }
-            (candidate, path)
-        } else {
-            // Existing branch: the name must stay exact, so only the
-            // directory — anything occupying it, ours or the operator's — is
-            // sidestepped with a numeric suffix (#77). The daemon never
-            // adopts what it finds.
-            let mut path = self.target_path(base_repo, branch);
-            let mut n = 1;
-            while path.symlink_metadata().is_ok() {
-                n += 1;
-                path = self.target_path_suffixed(base_repo, branch, n);
-            }
-            (branch.to_string(), path)
-        };
+        // Anything occupying the target — a tree we left behind, one the
+        // operator made, an unrelated directory — is sidestepped with a
+        // numeric suffix on the directory; the branch stays whatever was
+        // requested (#77). The daemon never adopts what it finds.
+        let mut path = self.target_path(base_repo, branch);
+        let mut n = 1;
+        while path.symlink_metadata().is_ok() {
+            n += 1;
+            path = self.target_path_suffixed(base_repo, branch, n);
+        }
         // The parent (`<repo>/worktrees` or the override root) may not exist
         // yet; the target itself must not.
         if let Some(parent) = path.parent() {
@@ -146,10 +129,10 @@ impl WorktreeManager {
         let mut cmd = Command::new("git");
         cmd.arg("-C").arg(base_repo).args(["worktree", "add"]);
         if create_branch {
-            cmd.arg("-b").arg(&branch).arg(&path);
+            cmd.arg("-b").arg(branch).arg(&path);
         } else {
             // Existing branch: `worktree add <path> <branch>` with no `-b`.
-            cmd.arg(&path).arg(&branch);
+            cmd.arg(&path).arg(branch);
         }
         let out = cmd.output()?;
         check(out)?;
@@ -283,17 +266,6 @@ fn branch_relpath(branch: &str) -> Option<PathBuf> {
     Some(candidate.to_path_buf())
 }
 
-/// Whether `refs/heads/<branch>` already exists in `base_repo`.
-fn branch_exists(base_repo: &Path, branch: &str) -> bool {
-    Command::new("git")
-        .arg("-C")
-        .arg(base_repo)
-        .args(["show-ref", "--verify", "--quiet"])
-        .arg(format!("refs/heads/{branch}"))
-        .status()
-        .is_ok_and(|s| s.success())
-}
-
 /// `git -C <base_repo> worktree prune` — drops registrations whose directory
 /// no longer exists.
 fn prune(base_repo: &Path) -> Result<(), WorktreeError> {

crates/maestro-daemon/tests/activity_report.rs

@@ -18,6 +18,7 @@ use uuid::Uuid;
 
 struct Fixture {
     manager: SessionManager,
+    sidecar: SidecarStore,
     _tmux: TmuxFixture,
     _state_dir: TempDir,
 }
@@ -25,15 +26,17 @@ struct Fixture {
 async fn fixture(ttl: Duration) -> Fixture {
     let tmux = TmuxFixture::new();
     let state_dir = TempDir::new().unwrap();
+    let sidecar = SidecarStore::new(state_dir.path().join("sessions"));
     let manager = SessionManager::new(
         Arc::new(tmux.tmux.clone()),
-        SidecarStore::new(state_dir.path().join("sessions")),
+        sidecar.clone(),
         WorktreeManager::new(None),
         state_dir.path().join("fifos"),
     )
     .with_activity_report_ttl(ttl);
     Fixture {
         manager,
+        sidecar,
         _tmux: tmux,
         _state_dir: state_dir,
     }
@@ -42,13 +45,11 @@ async fn fixture(ttl: Duration) -> Fixture {
 async fn spawn_sleeping(manager: &SessionManager) -> Uuid {
     manager
         .create(CreateSessionRequest {
-            view: Default::default(),
             cwd: "/tmp".into(),
             command: "sleep 60".into(),
             env: Default::default(),
             metadata: Default::default(),
             worktree: None,
-            auto_approve: false,
         })
         .await
         .unwrap()
@@ -69,7 +70,7 @@ async fn report_on_unknown_session_is_not_found() {
     let fx = fixture(Duration::from_secs(300)).await;
     let err = fx
         .manager
-        .report_activity(Uuid::new_v4(), ActivityState::Idle, None)
+        .report_activity(Uuid::new_v4(), ActivityState::Idle, None, None)
         .await
         .unwrap_err();
     assert!(matches!(err, maestro_daemon::SessionError::NotFound(_)));
@@ -85,6 +86,7 @@ async fn report_sets_error_state_and_detail() {
             id,
             ActivityState::Error,
             Some("cargo build failed: link error".into()),
+            None,
         )
         .await
         .unwrap();
@@ -103,7 +105,7 @@ async fn replacing_a_report_replaces_both_state_and_detail() {
     let id = spawn_sleeping(&fx.manager).await;
 
     fx.manager
-        .report_activity(id, ActivityState::Error, Some("first failure".into()))
+        .report_activity(id, ActivityState::Error, Some("first failure".into()), None)
         .await
         .unwrap();
     fx.manager
@@ -111,6 +113,7 @@ async fn replacing_a_report_replaces_both_state_and_detail() {
             id,
             ActivityState::AwaitingInput,
             Some("needs approval".into()),
+            None,
         )
         .await
         .unwrap();
@@ -127,7 +130,7 @@ async fn detail_is_capped_server_side() {
 
     let long = "x".repeat(10_000);
     fx.manager
-        .report_activity(id, ActivityState::Error, Some(long))
+        .report_activity(id, ActivityState::Error, Some(long), None)
         .await
         .unwrap();
 
@@ -146,7 +149,12 @@ async fn reported_state_survives_watcher_ticks_until_the_ttl_then_inference_resu
     fx.manager.start_liveness_watcher(Duration::from_millis(50));
 
     fx.manager
-        .report_activity(id, ActivityState::Error, Some("agent died mid-run".into()))
+        .report_activity(
+            id,
+            ActivityState::Error,
+            Some("agent died mid-run".into()),
+            None,
+        )
         .await
         .unwrap();
 
@@ -164,3 +172,100 @@ async fn reported_state_survives_watcher_ticks_until_the_ttl_then_inference_resu
     })
     .await;
 }
+
+#[tokio::test]
+async fn a_reported_session_id_is_recorded_on_the_session() {
+    let fx = fixture(Duration::from_secs(300)).await;
+    let id = spawn_sleeping(&fx.manager).await;
+
+    fx.manager
+        .report_activity(id, ActivityState::Active, None, Some("conv-abc123".into()))
+        .await
+        .unwrap();
+
+    let s = observed(&fx.manager, id).await;
+    assert_eq!(s.agent_session_id.as_deref(), Some("conv-abc123"));
+}
+
+/// #161: repeated reports of the same id are pure churn from the hook's
+/// `PreToolUse` cadence — the sidecar must not be rewritten for them.
+#[tokio::test]
+async fn a_repeated_report_of_the_same_session_id_writes_nothing() {
+    let fx = fixture(Duration::from_secs(300)).await;
+    let id = spawn_sleeping(&fx.manager).await;
+
+    fx.manager
+        .report_activity(id, ActivityState::Active, None, Some("conv-first".into()))
+        .await
+        .unwrap();
+    fx.manager
+        .report_activity(id, ActivityState::Active, None, Some("conv-first".into()))
+        .await
+        .unwrap();
+
+    let s = observed(&fx.manager, id).await;
+    assert_eq!(s.agent_session_id.as_deref(), Some("conv-first"));
+}
+
+/// #176: a resume issues a new conversation id. The stored id must move to
+/// it, or every later resume reattaches the stale pre-resume conversation.
+#[tokio::test]
+async fn a_reported_session_id_is_replaced_when_it_differs() {
+    let fx = fixture(Duration::from_secs(300)).await;
+    let id = spawn_sleeping(&fx.manager).await;
+
+    fx.manager
+        .report_activity(id, ActivityState::Active, None, Some("conv-first".into()))
+        .await
+        .unwrap();
+    fx.manager
+        .report_activity(id, ActivityState::Active, None, Some("conv-second".into()))
+        .await
+        .unwrap();
+
+    let s = observed(&fx.manager, id).await;
+    assert_eq!(s.agent_session_id.as_deref(), Some("conv-second"));
+
+    let stored = fx
+        .sidecar
+        .read(id)
+        .expect("sidecar read")
+        .expect("sidecar present");
+    assert_eq!(stored.agent_session_id.as_deref(), Some("conv-second"));
+}
+
+#[tokio::test]
+async fn a_reported_session_id_survives_recovery_from_the_sidecar() {
+    let fx = fixture(Duration::from_secs(300)).await;
+    let id = spawn_sleeping(&fx.manager).await;
+
+    fx.manager
+        .report_activity(id, ActivityState::Active, None, Some("conv-abc123".into()))
+        .await
+        .unwrap();
+
+    let stored = fx
+        .sidecar
+        .read(id)
+        .expect("sidecar read")
+        .expect("sidecar present");
+    assert_eq!(stored.agent_session_id.as_deref(), Some("conv-abc123"));
+
+    // The sidecar holding the id is only half the claim: a restarted daemon
+    // has to carry it back onto the recovered session, which is what a resume
+    // reads. Build a parallel manager over the same tmux server and state
+    // dirs and recover through it.
+    let revived = SessionManager::new(
+        Arc::new(fx._tmux.tmux.clone()),
+        fx.sidecar.clone(),
+        WorktreeManager::new(None),
+        fx._state_dir.path().join("fifos"),
+    );
+    revived.recover().await.expect("recover");
+    let recovered = observed(&revived, id).await;
+    assert_eq!(
+        recovered.agent_session_id.as_deref(),
+        Some("conv-abc123"),
+        "the recovered session must carry the agent session id, not just the sidecar"
+    );
+}

crates/maestro-daemon/tests/attach.rs

@@ -75,13 +75,11 @@ async fn create_bash_session(h: &Harness) -> Uuid {
     let s = h
         .manager
         .create(CreateSessionRequest {
-            view: Default::default(),
             cwd: cwd_path,
             command: "bash --noprofile --norc".into(),
             env: HashMap::new(),
             metadata: HashMap::new(),
             worktree: None,
-            auto_approve: false,
         })
         .await
         .unwrap();
@@ -96,6 +94,74 @@ async fn rejects_unknown_session() {
     assert!(format!("{err}").contains("404"));
 }
 
+/// #166: a session the daemon knows but has no bridge for is not unknown, it
+/// is not running. `404 unknown_session` made "gone" and "resumable" look the
+/// same to a client that could have offered a resume.
+#[tokio::test]
+async fn dormant_session_is_not_attachable_rather_than_unknown() {
+    let h = spawn_daemon_ws().await;
+    let cwd = TempDir::new().unwrap();
+    let session = h
+        .manager
+        .create(CreateSessionRequest {
+            cwd: cwd.path().to_path_buf(),
+            command: "sleep 30".into(),
+            env: HashMap::new(),
+            metadata: HashMap::new(),
+            worktree: None,
+        })
+        .await
+        .unwrap();
+
+    // The host reboot: tmux is gone, the sidecar is not, and a fresh manager
+    // registers the session dormant.
+    h._fx.tmux.tmux.kill_server().unwrap();
+    let dormant = SessionManager::new(
+        std::sync::Arc::new(h._fx.tmux.tmux.clone()),
+        maestro_daemon::sidecar::SidecarStore::new(h._fx.sidecar_dir()),
+        maestro_daemon::worktree::WorktreeManager::new(None),
+        h._fx.fifo_dir(),
+    );
+    dormant.recover().await.unwrap();
+    let dormant_addr = serve_manager(dormant).await;
+
+    let err = connect_attach(dormant_addr, session.id).await.unwrap_err();
+    let tokio_tungstenite::tungstenite::Error::Http(resp) = err else {
+        panic!("want an HTTP rejection, got {err}");
+    };
+    assert_eq!(resp.status().as_u16(), 409);
+    let body: maestro_protocol::ApiError =
+        serde_json::from_slice(resp.body().as_deref().expect("error body")).unwrap();
+    assert_eq!(body.error.code, "not_attachable");
+
+    // A session that really is unknown still reads as unknown.
+    let err = connect_attach(dormant_addr, Uuid::new_v4())
+        .await
+        .unwrap_err();
+    assert!(format!("{err}").contains("404"));
+}
+
+/// Serve `manager` on its own listener, for tests that need a second daemon
+/// over the same tmux/sidecar state.
+async fn serve_manager(manager: SessionManager) -> SocketAddr {
+    let router = local_api::router(local_api::state_for(
+        manager,
+        "test-host",
+        "/home/test",
+        Vec::new(),
+        std::sync::Arc::new(maestro_daemon::projects::ProjectScanner::disabled()),
+        maestro_config::DEFAULT_LEADER,
+    ));
+    let listener = TcpListener::bind(SocketAddr::from((Ipv4Addr::LOCALHOST, 0)))
+        .await
+        .unwrap();
+    let addr = listener.local_addr().unwrap();
+    tokio::spawn(async move {
+        let _ = axum::serve(listener, router).await;
+    });
+    addr
+}
+
 #[tokio::test]
 async fn pty_round_trip_through_real_tmux() {
     let h = spawn_daemon_ws().await;

crates/maestro-daemon/tests/autoname.rs

@@ -11,14 +11,14 @@ use common::TmuxFixture;
 use maestro_daemon::sidecar::SidecarStore;
 use maestro_daemon::worktree::WorktreeManager;
 use maestro_daemon::SessionManager;
-use maestro_protocol::{display, CatalogEvent, CreateSessionRequest, NameSource, SessionStatus};
+use maestro_protocol::{display, CatalogEvent, CreateSessionRequest, NameSource};
 use tempfile::TempDir;
 use uuid::Uuid;
 
 struct Fixture {
     manager: SessionManager,
     sidecar: SidecarStore,
-    tmux: TmuxFixture,
+    _tmux: TmuxFixture,
     _state_dir: TempDir,
 }
 
@@ -35,7 +35,7 @@ fn fixture() -> Fixture {
     Fixture {
         manager,
         sidecar,
-        tmux,
+        _tmux: tmux,
         _state_dir: state_dir,
     }
 }
@@ -50,13 +50,11 @@ async fn spawn(manager: &SessionManager, name: Option<&str>) -> Uuid {
     };
     manager
         .create(CreateSessionRequest {
-            view: Default::default(),
             cwd: "/tmp".into(),
             command: "sleep 60".into(),
             env: Default::default(),
             metadata,
             worktree: None,
-            auto_approve: false,
         })
         .await
         .unwrap()
@@ -171,37 +169,3 @@ async fn a_blank_name_changes_nothing() {
     let live = fx.sidecar.read(id).unwrap().unwrap();
     assert_eq!(display::name_source(&live), NameSource::Generated);
 }
-
-/// A session that dies naturally (liveness watcher marks it dead) must not
-/// overwrite a haiku rename that landed before the death. Regression test for
-/// the stale-clone sidecar write in `mark_session_dead`.
-#[tokio::test]
-async fn session_death_preserves_the_haiku_name() {
-    let fx = fixture();
-    let id = spawn(&fx.manager, None).await;
-
-    fx.manager.claim_autoname(id).await.unwrap();
-    fx.manager.apply_autoname(id, "haiku-name").await.unwrap();
-
-    // Verify the sidecar has Haiku before the session dies.
-    let before = fx.sidecar.read(id).unwrap().unwrap();
-    assert_eq!(display::name_source(&before), NameSource::Haiku);
-
-    // Kill the tmux session directly so the liveness watcher picks it up.
-    fx.tmux.tmux.kill_session(id).expect("kill tmux directly");
-    fx.manager
-        .start_liveness_watcher(std::time::Duration::from_millis(25));
-
-    common::wait_for_async(std::time::Duration::from_secs(3), || async {
-        fx.manager.status(id).await == Some(SessionStatus::Dead)
-    })
-    .await;
-
-    let after = fx.sidecar.read(id).unwrap().unwrap();
-    assert_eq!(
-        display::name_source(&after),
-        NameSource::Haiku,
-        "mark_session_dead must not overwrite a haiku rename in the sidecar"
-    );
-    assert_eq!(display::custom_name(&after), Some("haiku-name"));
-}

crates/maestro-daemon/tests/blocked_work_cost.rs

@@ -14,12 +14,11 @@ use std::process::Command;
 use std::time::Duration;
 
 use common::{init_bare_repo, init_repo, push_all_to_origin, wait_for_async, DaemonFixture};
-use maestro_protocol::{CreateSessionRequest, InTheWay, WorktreeSpec};
+use maestro_protocol::{CreateSessionRequest, WorktreeSpec};
 use tempfile::TempDir;
 
 fn request(cwd: &std::path::Path, repo: &std::path::Path, branch: &str) -> CreateSessionRequest {
     CreateSessionRequest {
-        view: Default::default(),
         cwd: cwd.to_path_buf(),
         command: "sleep 30".into(),
         env: HashMap::new(),
@@ -29,7 +28,6 @@ fn request(cwd: &std::path::Path, repo: &std::path::Path, branch: &str) -> Creat
             branch: branch.into(),
             create_branch: true,
         }),
-        auto_approve: false,
     }
 }
 
@@ -93,13 +91,12 @@ async fn a_session_without_a_worktree_costs_no_probe() {
         Duration::from_millis(100),
     );
 
-    // The pass demonstrably runs and probed A's tree...
-    wait_for_async(Duration::from_secs(5), || async {
-        fx.manager
-            .snapshot()
-            .await
-            .iter()
-            .any(|s| s.worktree.is_some() && s.blocked_work == Some(InTheWay::default()))
+    // 30s is a hang guard only, not the property under test — that's the
+    // timing-free `contains` check below.
+    wait_for_async(Duration::from_secs(30), || async {
+        std::fs::read_to_string(&log_path)
+            .map(|calls| calls.contains(repo_a.path().to_str().unwrap()))
+            .unwrap_or(false)
     })
     .await;
 

crates/maestro-daemon/tests/common/mod.rs

@@ -151,27 +151,40 @@ pub struct DaemonFixture {
 
 impl DaemonFixture {
     pub fn new() -> Self {
-        Self::build(None)
+        Self::build(None, maestro_daemon::pty::DEFAULT_REPLAY_BYTES)
+    }
+
+    /// Variant whose manager runs a custom PTY replay budget (NAP-229), which
+    /// also caps the scrollback it persists (#171).
+    pub fn new_with_replay(replay_bytes: usize) -> Self {
+        Self::build(None, replay_bytes)
     }
 
     /// Variant whose manager has a durable spawn history (#24) attached, with
     /// `retention_days` recency cap, logging to `<state_dir>/spawn-history.jsonl`.
     pub fn new_with_history(retention_days: u32) -> Self {
-        Self::build(Some(retention_days))
+        Self::build(
+            Some(retention_days),
+            maestro_daemon::pty::DEFAULT_REPLAY_BYTES,
+        )
     }
 
-    fn build(history_days: Option<u32>) -> Self {
+    fn build(history_days: Option<u32>, replay_bytes: usize) -> Self {
         let tmux = TmuxFixture::new();
         let state_dir = TempDir::new().unwrap();
         let sidecar = SidecarStore::new(state_dir.path().join("sessions"));
         // Default placement: worktrees land under their base repo (#56).
         let worktree_mgr = WorktreeManager::new(None);
-        let mut manager = SessionManager::new(
+        let mut manager = SessionManager::new_with_replay(
             Arc::new(tmux.tmux.clone()),
             sidecar,
             worktree_mgr,
             state_dir.path().join("fifos"),
+            replay_bytes,
         );
+        // #171: production wires this, so the fixtures do too — every test
+        // then exercises the same flush/restore/delete paths the daemon runs.
+        manager = manager.with_scrollback(state_dir.path().join("scrollback"));
         if let Some(days) = history_days {
             manager =
                 manager.with_spawn_history(SpawnHistory::new(Self::history_path(&state_dir), days));
@@ -198,4 +211,8 @@ impl DaemonFixture {
     pub fn fifo_dir(&self) -> PathBuf {
         self.state_dir.path().join("fifos")
     }
+
+    pub fn scrollback_dir(&self) -> PathBuf {
+        self.state_dir.path().join("scrollback")
+    }
 }

crates/maestro-daemon/tests/embedded_bundle.rs

@@ -13,14 +13,14 @@ async fn embedded_index_is_real_spa_not_placeholder() {
     let html = String::from_utf8(body.to_vec()).unwrap();
 
     assert!(
-        html.contains(r#"id="root""#),
+        html.contains(r#"id="app""#),
         "served index is missing the SPA mount point; got:\n{html}"
     );
     assert!(
         !html.contains("maestro is running"),
         "served index is the placeholder, not the built bundle"
     );
-    // Stronger signal than `id="root"` (which appears in both source and built
+    // Stronger signal than `id="app"` (which appears in both source and built
     // HTML): the vite build rewrites the entry to a hashed `/assets/index-<hash>`
     // bundle, whereas the un-built source references `/src/main.ts`. This catches
     // both an empty/placeholder embed and the staleness case.

crates/maestro-daemon/tests/fixtures/codex-acp-session.jsonl

@@ -1,16 +0,0 @@
-{"sessionId":"codex-session","update":{"sessionUpdate":"user_message_chunk","messageId":"user-1","content":{"type":"text","text":"Inspect the repository"}}}
-{"sessionId":"codex-session","update":{"sessionUpdate":"agent_thought_chunk","messageId":"thought-1","content":{"type":"text","text":"I should inspect the files first."}}}
-{"sessionId":"codex-session","update":{"sessionUpdate":"tool_call","toolCallId":"command-1","kind":"execute","title":"rg TODO","status":"in_progress","rawInput":{"command":"rg TODO","cwd":"/workspace"}}}
-{"sessionId":"codex-session","update":{"sessionUpdate":"tool_call_update","toolCallId":"command-1","status":"completed","rawOutput":{"formatted_output":"src/lib.rs: TODO","exit_code":0}}}
-{"sessionId":"codex-session","update":{"sessionUpdate":"tool_call","toolCallId":"change-1","kind":"edit","title":"Editing files","status":"completed","content":[{"type":"diff","path":"src/lib.rs","oldText":"old","newText":"new"}]}}
-{"sessionId":"codex-session","update":{"sessionUpdate":"tool_call","toolCallId":"mcp-1","kind":"execute","title":"mcp.github.search","status":"completed","rawInput":{"server":"github","tool":"search","arguments":{"query":"ACP"}},"rawOutput":{"result":"found"},"_meta":{"is_mcp_tool_call":true}}}
-{"sessionId":"codex-session","update":{"sessionUpdate":"tool_call","toolCallId":"web-1","kind":"search","title":"Search the web for ACP","status":"completed","rawInput":{"type":"webSearch","query":"Agent Client Protocol"}}}
-{"sessionId":"codex-session","update":{"sessionUpdate":"tool_call","toolCallId":"image-view-1","kind":"read","title":"View Image /workspace/diagram.png","status":"completed","content":[{"type":"content","content":{"type":"resource_link","name":"/workspace/diagram.png","uri":"/workspace/diagram.png"}}]}}
-{"sessionId":"codex-session","update":{"sessionUpdate":"tool_call","toolCallId":"image-gen-1","title":"Image generation","status":"completed","content":[{"type":"content","content":{"type":"image","data":"aW1hZ2U=","mimeType":"image/png"}}],"rawOutput":{"path":"/workspace/generated.png"}}}
-{"sessionId":"codex-session","update":{"sessionUpdate":"plan","entries":[{"content":"Implement compatibility fixture","priority":"medium","status":"in_progress"}]}}
-{"sessionId":"codex-session","update":{"sessionUpdate":"usage_update","used":1200,"size":258400}}
-{"sessionId":"codex-session","update":{"sessionUpdate":"current_mode_update","currentModeId":"agent"}}
-{"sessionId":"codex-session","update":{"sessionUpdate":"config_option_update","configOptions":[{"id":"agent-mode","name":"Agent mode","category":"mode","type":"select","currentValue":"agent","options":[{"value":"read-only","name":"Read-only"},{"value":"agent","name":"Agent"}]},{"id":"model","name":"Model","category":"model","type":"select","currentValue":"gpt-5.3-codex","options":[{"value":"gpt-5.3-codex","name":"GPT-5.3-Codex"}]},{"id":"reasoning_effort","name":"Reasoning effort","category":"thought_level","type":"select","currentValue":"high","options":[{"value":"high","name":"High"}]},{"id":"fast-mode","name":"Fast mode","category":"model_config","type":"select","currentValue":"off","options":[{"value":"off","name":"Off"}]}]}}
-{"sessionId":"codex-session","update":{"sessionUpdate":"available_commands_update","availableCommands":[{"name":"status","description":"Show session status"}]}}
-{"sessionId":"codex-session","update":{"sessionUpdate":"session_info_update","title":"Codex session"}}
-{"sessionId":"codex-session","update":{"sessionUpdate":"agent_message_chunk","messageId":"assistant-1","content":{"type":"text","text":"Done."}}}

crates/maestro-daemon/tests/local_api.rs

@@ -4,17 +4,12 @@ mod common;
 
 use std::collections::HashMap;
 use std::net::{Ipv4Addr, SocketAddr};
-use std::path::Path;
 use std::time::Duration;
 
 use common::DaemonFixture;
 use futures_util::{SinkExt, StreamExt};
 use maestro_daemon::local_api;
-use maestro_protocol::{
-    ActivityState, ApiError, CreateSessionRequest, Session, SessionStatus, SessionView,
-    WorktreeSpec,
-};
-use tempfile::TempDir;
+use maestro_protocol::{ApiError, CreateSessionRequest, Session, WorktreeSpec};
 use tokio::net::TcpListener;
 use tokio::sync::oneshot;
 use tokio_tungstenite::tungstenite::Message as WsMessage;
@@ -91,640 +86,6 @@ fn ws_url(addr: SocketAddr, path: &str) -> String {
     format!("ws://{addr}{path}")
 }
 
-struct FakeAcp {
-    dir: TempDir,
-}
-
-impl FakeAcp {
-    fn new() -> Self {
-        use std::os::unix::fs::PermissionsExt;
-
-        let dir = TempDir::new().unwrap();
-        let bin = dir.path().join("bin");
-        std::fs::create_dir_all(&bin).unwrap();
-        let adapter = bin.join("claude-code-acp");
-        std::fs::copy(
-            Path::new(env!("CARGO_MANIFEST_DIR")).join("../maestro-acp/tests/fake_acp_agent.py"),
-            &adapter,
-        )
-        .unwrap();
-        std::fs::set_permissions(&adapter, std::fs::Permissions::from_mode(0o755)).unwrap();
-        Self { dir }
-    }
-
-    fn env(&self) -> HashMap<String, String> {
-        HashMap::from([
-            (
-                "PATH".into(),
-                format!(
-                    "{}:{}",
-                    self.dir.path().join("bin").display(),
-                    std::env::var("PATH").unwrap()
-                ),
-            ),
-            (
-                "FAKE_ACP_LOG".into(),
-                self.dir.path().join("agent.log").display().to_string(),
-            ),
-        ])
-    }
-
-    fn pid(&self) -> u32 {
-        std::fs::read_to_string(self.dir.path().join("agent.log"))
-            .unwrap_or_default()
-            .lines()
-            .filter_map(|line| {
-                line.strip_prefix("start pid=")?
-                    .split(' ')
-                    .next()?
-                    .parse()
-                    .ok()
-            })
-            .next_back()
-            .expect("fake ACP started")
-    }
-
-    fn log(&self) -> String {
-        std::fs::read_to_string(self.dir.path().join("agent.log")).unwrap_or_default()
-    }
-}
-
-async fn structured_session(h: &Harness, fake: &FakeAcp) -> Uuid {
-    structured_session_with_env(h, fake.env()).await
-}
-
-async fn structured_session_with_env(h: &Harness, env: HashMap<String, String>) -> Uuid {
-    let id = h
-        .manager
-        .create(CreateSessionRequest {
-            view: SessionView::Structured,
-            cwd: "/tmp".into(),
-            command: "claude".into(),
-            env,
-            metadata: HashMap::new(),
-            worktree: None,
-            auto_approve: false,
-        })
-        .await
-        .unwrap()
-        .id;
-    wait_for_session_activity(h, id, ActivityState::Idle).await;
-    id
-}
-
-async fn wait_for_session_activity(h: &Harness, id: Uuid, expected: ActivityState) {
-    tokio::time::timeout(Duration::from_secs(2), async {
-        loop {
-            let sessions: Vec<Session> = reqwest::get(url(h.addr, "/api/sessions"))
-                .await
-                .unwrap()
-                .json()
-                .await
-                .unwrap();
-            if sessions
-                .iter()
-                .find(|session| session.id == id)
-                .is_some_and(|session| session.activity == expected)
-            {
-                return;
-            }
-            tokio::time::sleep(Duration::from_millis(10)).await;
-        }
-    })
-    .await
-    .unwrap_or_else(|_| panic!("session {id} did not reach {expected:?}"));
-}
-
-#[tokio::test]
-async fn structured_ws_sends_snapshot_then_live_projection() {
-    let h = spawn("naps-laptop").await;
-    let fake = FakeAcp::new();
-    let id = structured_session(&h, &fake).await;
-    let (mut ws, _) = connect_async(ws_url(h.addr, &format!("/api/structured/{id}")))
-        .await
-        .unwrap();
-
-    let first = ws.next().await.unwrap().unwrap().into_text().unwrap();
-    let second = ws.next().await.unwrap().unwrap().into_text().unwrap();
-    assert_eq!(
-        serde_json::from_str::<serde_json::Value>(&first).unwrap()["type"],
-        "transcript_snapshot"
-    );
-    assert_eq!(
-        serde_json::from_str::<serde_json::Value>(&second).unwrap()["type"],
-        "reduced_state"
-    );
-
-    let response = reqwest::Client::new()
-        .post(url(
-            h.addr,
-            &format!("/api/sessions/{id}/structured/prompt"),
-        ))
-        .json(&serde_json::json!({"prompt": "hello"}))
-        .send()
-        .await
-        .unwrap();
-    assert_eq!(response.status(), reqwest::StatusCode::NO_CONTENT);
-    let live = tokio::time::timeout(Duration::from_secs(1), ws.next())
-        .await
-        .expect("projection update arrives on the subscribed stream")
-        .unwrap()
-        .unwrap()
-        .into_text()
-        .unwrap();
-    assert_eq!(
-        serde_json::from_str::<serde_json::Value>(&live).unwrap()["type"],
-        "projection_update"
-    );
-}
-
-#[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_queues_during_active_turn_and_cancel_clears_it() {
-    let h = spawn("naps-laptop").await;
-    let fake = FakeAcp::new();
-    let mut env = fake.env();
-    env.insert("FAKE_ACP_DELAY_PROMPT_MS".into(), "200".into());
-    let id = structured_session_with_env(&h, env).await;
-    let client = reqwest::Client::new();
-    let first = client
-        .post(url(
-            h.addr,
-            &format!("/api/sessions/{id}/structured/prompt"),
-        ))
-        .json(&serde_json::json!({"prompt": "first"}))
-        .send()
-        .await
-        .unwrap();
-    assert_eq!(first.status(), reqwest::StatusCode::NO_CONTENT);
-    // A second prompt while a turn is active is accepted into the queue.
-    let second = client
-        .post(url(
-            h.addr,
-            &format!("/api/sessions/{id}/structured/prompt"),
-        ))
-        .json(&serde_json::json!({"prompt": "second"}))
-        .send()
-        .await
-        .unwrap();
-    assert_eq!(second.status(), reqwest::StatusCode::ACCEPTED);
-
-    let cancel = client
-        .post(url(
-            h.addr,
-            &format!("/api/sessions/{id}/structured/cancel"),
-        ))
-        .send()
-        .await
-        .unwrap();
-    assert_eq!(cancel.status(), reqwest::StatusCode::NO_CONTENT);
-    // After cancel + settlement, the queued "second" prompt drains. Wait for
-    // both the first and the drained prompt to reach ACP.
-    tokio::time::timeout(Duration::from_secs(2), async {
-        loop {
-            if fake.log().matches("recv session/prompt").count() == 2 {
-                break;
-            }
-            tokio::time::sleep(Duration::from_millis(10)).await;
-        }
-    })
-    .await
-    .expect("first and drained queued prompt both reach ACP");
-    let log = fake.log();
-    let first_prompt = log.find("recv session/prompt").unwrap();
-    let cancel = log.find("recv session/cancel").unwrap();
-    let second_prompt = log.rfind("recv session/prompt").unwrap();
-    assert!(first_prompt < cancel && cancel < second_prompt, "{log}");
-}
-
-#[tokio::test]
-async fn structured_approval_is_secret_single_use_and_race_safe() {
-    let h = spawn("naps-laptop").await;
-    let fake = FakeAcp::new();
-    let mut env = fake.env();
-    env.insert("FAKE_ACP_REQUEST_PERMISSION".into(), "1".into());
-    let id = structured_session_with_env(&h, env).await;
-    let client = reqwest::Client::new();
-    let (mut ws, _) = connect_async(ws_url(h.addr, &format!("/api/structured/{id}")))
-        .await
-        .unwrap();
-    ws.next().await.unwrap().unwrap();
-    ws.next().await.unwrap().unwrap();
-    assert_eq!(
-        client
-            .post(url(
-                h.addr,
-                &format!("/api/sessions/{id}/structured/prompt")
-            ))
-            .json(&serde_json::json!({"prompt":"needs permission"}))
-            .send()
-            .await
-            .unwrap()
-            .status(),
-        reqwest::StatusCode::NO_CONTENT
-    );
-
-    let nonce = tokio::time::timeout(Duration::from_secs(2), async {
-        loop {
-            let event: serde_json::Value =
-                serde_json::from_str(&ws.next().await.unwrap().unwrap().into_text().unwrap())
-                    .unwrap();
-            if let Some(nonce) = event["state"]["pending_approval"]["nonce"].as_str() {
-                assert_eq!(event["transcript"]["row"]["kind"], "approval");
-                assert!(event["transcript"]["row"]["data"].get("nonce").is_none());
-                break nonce.to_owned();
-            }
-        }
-    })
-    .await
-    .unwrap();
-    wait_for_session_activity(&h, id, ActivityState::AwaitingInput).await;
-    assert!(
-        !fake.log().contains(&nonce),
-        "daemon nonce leaked to ACP agent"
-    );
-
-    let path = format!("/api/sessions/{id}/structured/approvals/{nonce}");
-    let (a, b) = tokio::join!(
-        client
-            .post(url(h.addr, &path))
-            .json(&serde_json::json!("allow_once"))
-            .send(),
-        client
-            .post(url(h.addr, &path))
-            .json(&serde_json::json!("deny"))
-            .send(),
-    );
-    assert_eq!(a.unwrap().status(), reqwest::StatusCode::NO_CONTENT);
-    assert_eq!(b.unwrap().status(), reqwest::StatusCode::NO_CONTENT);
-    assert_eq!(
-        client
-            .post(url(h.addr, &path))
-            .json(&serde_json::json!("deny"))
-            .send()
-            .await
-            .unwrap()
-            .status(),
-        reqwest::StatusCode::NO_CONTENT
-    );
-    tokio::time::timeout(Duration::from_secs(2), async {
-        loop {
-            if fake.log().contains("permission response") {
-                break;
-            }
-            tokio::time::sleep(Duration::from_millis(10)).await;
-        }
-    })
-    .await
-    .unwrap();
-    let log = fake.log();
-    assert!(
-        log.contains("\"optionId\": \"once\"") || log.contains("\"optionId\": \"deny\""),
-        "{log}"
-    );
-    tokio::time::timeout(Duration::from_secs(1), async {
-        loop {
-            let event: serde_json::Value =
-                serde_json::from_str(&ws.next().await.unwrap().unwrap().into_text().unwrap())
-                    .unwrap();
-            if event["state"]["pending_approval"].is_null() {
-                break;
-            }
-        }
-    })
-    .await
-    .expect("resolved approval clears the reduced state");
-    wait_for_session_activity(&h, id, ActivityState::Idle).await;
-    assert_eq!(
-        client
-            .post(url(
-                h.addr,
-                &format!(
-                    "/api/sessions/{}/structured/approvals/{nonce}",
-                    Uuid::new_v4()
-                )
-            ))
-            .json(&serde_json::json!("deny"))
-            .send()
-            .await
-            .unwrap()
-            .status(),
-        reqwest::StatusCode::NOT_FOUND
-    );
-}
-
-#[tokio::test]
-async fn structured_prompt_failure_clears_the_turn() {
-    let h = spawn("naps-laptop").await;
-    let fake = FakeAcp::new();
-    let mut env = fake.env();
-    env.insert("FAKE_ACP_PROMPT_FAIL_ONCE".into(), "1".into());
-    let id = structured_session_with_env(&h, env).await;
-    let client = reqwest::Client::new();
-    let path = format!("/api/sessions/{id}/structured/prompt");
-    let (mut ws, _) = connect_async(ws_url(h.addr, &format!("/api/structured/{id}")))
-        .await
-        .unwrap();
-    ws.next().await.unwrap().unwrap();
-    ws.next().await.unwrap().unwrap();
-    let first = client
-        .post(url(h.addr, &path))
-        .json(&serde_json::json!({"prompt":"fails"}))
-        .send()
-        .await
-        .unwrap();
-    assert_eq!(first.status(), reqwest::StatusCode::NO_CONTENT);
-    let mut saw_active_turn = false;
-    tokio::time::timeout(Duration::from_secs(1), async {
-        while let Some(Ok(message)) = ws.next().await {
-            let event: serde_json::Value =
-                serde_json::from_str(&message.into_text().unwrap()).unwrap();
-            let turn = &event["state"]["turn"];
-            if turn["responding"] == true {
-                saw_active_turn = true;
-            }
-            if saw_active_turn && turn["responding"] == false && turn["thinking"] == false {
-                return;
-            }
-        }
-        panic!("structured websocket closed before the failed turn cleared");
-    })
-    .await
-    .expect("failed turn clears promptly");
-    wait_for_session_activity(&h, id, ActivityState::Error).await;
-    let second = client
-        .post(url(h.addr, &path))
-        .json(&serde_json::json!({"prompt":"available"}))
-        .send()
-        .await
-        .unwrap();
-    assert_eq!(second.status(), reqwest::StatusCode::NO_CONTENT);
-    assert!(second.bytes().await.unwrap().is_empty());
-}
-
-#[tokio::test]
-async fn structured_prompt_rejects_unknown_and_unavailable_sessions() {
-    let h = spawn("naps-laptop").await;
-    let client = reqwest::Client::new();
-    let prompt = |id| {
-        client
-            .post(url(
-                h.addr,
-                &format!("/api/sessions/{id}/structured/prompt"),
-            ))
-            .json(&serde_json::json!({"prompt": "hello"}))
-    };
-
-    let unknown = prompt(Uuid::new_v4()).send().await.unwrap();
-    assert_eq!(unknown.status(), reqwest::StatusCode::NOT_FOUND);
-    let error: ApiError = unknown.json().await.unwrap();
-    assert_eq!(error.error.code, "not_found");
-
-    let terminal = h
-        .manager
-        .create(CreateSessionRequest {
-            view: SessionView::Terminal,
-            cwd: "/tmp".into(),
-            command: "sh".into(),
-            env: HashMap::new(),
-            metadata: HashMap::new(),
-            worktree: None,
-            auto_approve: false,
-        })
-        .await
-        .unwrap();
-    let non_structured = prompt(terminal.id).send().await.unwrap();
-    assert_eq!(non_structured.status(), reqwest::StatusCode::CONFLICT);
-    let error: ApiError = non_structured.json().await.unwrap();
-    assert_eq!(error.error.code, "not_structured");
-
-    let fake = FakeAcp::new();
-    let dead = structured_session(&h, &fake).await;
-    h.manager.shutdown().await;
-    assert_eq!(h.manager.status(dead).await, Some(SessionStatus::Dead));
-    let unavailable = prompt(dead).send().await.unwrap();
-    assert_eq!(unavailable.status(), reqwest::StatusCode::CONFLICT);
-    let error: ApiError = unavailable.json().await.unwrap();
-    assert_eq!(error.error.code, "not_structured");
-}
-
-#[tokio::test]
-async fn structured_replay_honors_cursors_and_limit() {
-    let h = spawn("naps-laptop").await;
-    let fake = FakeAcp::new();
-    let id = structured_session(&h, &fake).await;
-    let client = reqwest::Client::new();
-
-    let events: Vec<serde_json::Value> = tokio::time::timeout(Duration::from_secs(2), async {
-        loop {
-            let events: Vec<serde_json::Value> = client
-                .get(url(
-                    h.addr,
-                    &format!("/api/sessions/{id}/structured/replay?since=0&limit=1"),
-                ))
-                .send()
-                .await
-                .unwrap()
-                .json()
-                .await
-                .unwrap();
-            if !events.is_empty() {
-                return events;
-            }
-            tokio::time::sleep(Duration::from_millis(10)).await;
-        }
-    })
-    .await
-    .unwrap();
-    assert_eq!(events.len(), 1);
-    assert_eq!(events[0]["cursor"], 1);
-    assert!(events[0].get("notification").is_none());
-
-    let invalid = client
-        .get(url(
-            h.addr,
-            &format!("/api/sessions/{id}/structured/replay?since=0&before=2"),
-        ))
-        .send()
-        .await
-        .unwrap();
-    assert_eq!(invalid.status(), reqwest::StatusCode::BAD_REQUEST);
-}
-
-#[tokio::test]
-async fn structured_replay_pages_projected_events_in_cursor_order() {
-    let h = spawn("naps-laptop").await;
-    let fake = FakeAcp::new();
-    let id = structured_session(&h, &fake).await;
-    let client = reqwest::Client::new();
-    unsafe { libc::kill(fake.pid() as libc::pid_t, libc::SIGUSR1) };
-    let events: Vec<serde_json::Value> = tokio::time::timeout(Duration::from_secs(2), async {
-        loop {
-            let events: Vec<serde_json::Value> = client
-                .get(url(
-                    h.addr,
-                    &format!("/api/sessions/{id}/structured/replay?before=99&limit=2"),
-                ))
-                .send()
-                .await
-                .unwrap()
-                .json()
-                .await
-                .unwrap();
-            if events.len() == 2 {
-                return events;
-            }
-            tokio::time::sleep(Duration::from_millis(10)).await;
-        }
-    })
-    .await
-    .unwrap();
-    assert_eq!(
-        events
-            .iter()
-            .map(|event| event["cursor"].as_u64().unwrap())
-            .collect::<Vec<_>>(),
-        vec![1, 2]
-    );
-    let boundary: Vec<serde_json::Value> = client
-        .get(url(
-            h.addr,
-            &format!("/api/sessions/{id}/structured/replay?before=2&limit=10"),
-        ))
-        .send()
-        .await
-        .unwrap()
-        .json()
-        .await
-        .unwrap();
-    assert_eq!(boundary.len(), 1);
-    assert_eq!(boundary[0]["cursor"], 1);
-}
-
-#[tokio::test]
-async fn structured_replay_rejects_unknown_terminal_and_dead_sessions() {
-    let h = spawn("naps-laptop").await;
-    let client = reqwest::Client::new();
-    let unknown = client
-        .get(url(
-            h.addr,
-            &format!("/api/sessions/{}/structured/replay", Uuid::new_v4()),
-        ))
-        .send()
-        .await
-        .unwrap();
-    assert_eq!(unknown.status(), reqwest::StatusCode::NOT_FOUND);
-    let terminal = h
-        .manager
-        .create(CreateSessionRequest {
-            view: SessionView::Terminal,
-            cwd: "/tmp".into(),
-            command: "sh".into(),
-            env: HashMap::new(),
-            metadata: HashMap::new(),
-            worktree: None,
-            auto_approve: false,
-        })
-        .await
-        .unwrap();
-    let response = client
-        .get(url(
-            h.addr,
-            &format!("/api/sessions/{}/structured/replay", terminal.id),
-        ))
-        .send()
-        .await
-        .unwrap();
-    assert_eq!(response.status(), reqwest::StatusCode::CONFLICT);
-
-    let fake = FakeAcp::new();
-    let dead = structured_session(&h, &fake).await;
-    h.manager.shutdown().await;
-    assert_eq!(h.manager.status(dead).await, Some(SessionStatus::Dead));
-    let response = client
-        .get(url(
-            h.addr,
-            &format!("/api/sessions/{dead}/structured/replay"),
-        ))
-        .send()
-        .await
-        .unwrap();
-    assert_eq!(response.status(), reqwest::StatusCode::CONFLICT);
-    let error: ApiError = response.json().await.unwrap();
-    assert_eq!(error.error.code, "not_structured");
-}
-
-#[tokio::test]
-async fn structured_ws_rejects_a_dead_session() {
-    let h = spawn("naps-laptop").await;
-    let fake = FakeAcp::new();
-    let id = structured_session(&h, &fake).await;
-    h.manager.shutdown().await;
-    assert_eq!(h.manager.status(id).await, Some(SessionStatus::Dead));
-
-    let err = connect_async(ws_url(h.addr, &format!("/api/structured/{id}")))
-        .await
-        .expect_err("dead structured session must not upgrade");
-    let message = err.to_string();
-    assert!(
-        message.contains("409") || message.to_lowercase().contains("conflict"),
-        "{message}"
-    );
-}
-
 #[tokio::test]
 async fn info_returns_daemon_identity() {
     let h = spawn("naps-laptop").await;
@@ -813,13 +174,11 @@ async fn list_sessions_starts_empty_and_reflects_creates() {
     assert!(empty.is_empty());
 
     let req = CreateSessionRequest {
-        view: Default::default(),
         cwd: "/tmp".into(),
         command: "sleep 60".into(),
         env: HashMap::new(),
         metadata: HashMap::new(),
         worktree: None,
-        auto_approve: false,
     };
     let created: Session = reqwest::Client::new()
         .post(url(h.addr, "/api/sessions"))
@@ -994,9 +353,7 @@ async fn names_honors_count_and_caps_it() {
 #[tokio::test]
 async fn gitroot_probes_path() {
     // #26: resolves the query against the daemon home dir and walks up for a
-    // `.git`. The tempdir itself has no `.git`, so the result must either be
-    // null (no repo anywhere above) or — in sandboxed environments where /tmp
-    // itself sits inside a repo — a path strictly above the tempdir.
+    // `.git`. A `/tmp`-rooted temp dir is not in a repo, so the root is null.
     let h = spawn("naps-laptop").await;
     let tmp = tempfile::tempdir().unwrap();
     let resp: serde_json::Value = reqwest::get(url(
@@ -1011,16 +368,7 @@ async fn gitroot_probes_path() {
     .json()
     .await
     .unwrap();
-    // On hosts where an ancestor of the temp dir is a repo (e.g. `/tmp`
-    // inside a checkout), the root legitimately points there. The test only
-    // asserts no root was found *inside* the temp dir.
-    match resp.get("root").and_then(|v| v.as_str()) {
-        None => {}
-        Some(root) => assert!(
-            !root.starts_with(tmp.path().to_string_lossy().as_ref()),
-            "found a repo root inside the fixture at {root:?}"
-        ),
-    }
+    assert!(resp.get("root").is_none() || resp["root"].is_null());
 }
 
 #[tokio::test]
@@ -1042,13 +390,11 @@ async fn patch_session_renames_it() {
     let session = h
         .manager
         .create(CreateSessionRequest {
-            view: Default::default(),
             cwd: "/tmp".into(),
             command: "sleep 60".into(),
             env: HashMap::new(),
             metadata: HashMap::new(),
             worktree: None,
-            auto_approve: false,
         })
         .await
         .unwrap();
@@ -1086,13 +432,11 @@ async fn post_focus_stamps_last_focused_at() {
     let session = h
         .manager
         .create(CreateSessionRequest {
-            view: Default::default(),
             cwd: "/tmp".into(),
             command: "sleep 60".into(),
             env: HashMap::new(),
             metadata: HashMap::new(),
             worktree: None,
-            auto_approve: false,
         })
         .await
         .unwrap();
@@ -1121,13 +465,11 @@ async fn delete_owned_session_kills_it() {
     let session = h
         .manager
         .create(CreateSessionRequest {
-            view: Default::default(),
             cwd: "/tmp".into(),
             command: "sleep 60".into(),
             env: HashMap::new(),
             metadata: HashMap::new(),
             worktree: None,
-            auto_approve: false,
         })
         .await
         .unwrap();
@@ -1144,13 +486,11 @@ async fn delete_owned_session_kills_it() {
 async fn spawn_via_manager(h: &Harness) -> Uuid {
     h.manager
         .create(CreateSessionRequest {
-            view: Default::default(),
             cwd: "/tmp".into(),
             command: "sleep 60".into(),
             env: HashMap::new(),
             metadata: HashMap::new(),
             worktree: None,
-            auto_approve: false,
         })
         .await
         .unwrap()
@@ -1186,6 +526,33 @@ async fn post_activity_reports_error_with_detail() {
     assert_eq!(s.activity_detail.as_deref(), Some("cargo build failed"));
 }
 
+/// #161: a reported `session_id` lands on the session as `agent_session_id`.
+#[tokio::test]
+async fn post_activity_records_the_reported_session_id() {
+    let h = spawn("naps-laptop").await;
+    let id = spawn_via_manager(&h).await;
+
+    let resp = reqwest::Client::new()
+        .post(url(h.addr, &format!("/api/sessions/{id}/activity")))
+        .json(&serde_json::json!({
+            "state": "Active",
+            "session_id": "conv-abc123"
+        }))
+        .send()
+        .await
+        .unwrap();
+    assert_eq!(resp.status(), reqwest::StatusCode::NO_CONTENT);
+
+    let sessions: Vec<Session> = reqwest::get(url(h.addr, "/api/sessions"))
+        .await
+        .unwrap()
+        .json()
+        .await
+        .unwrap();
+    let s = sessions.iter().find(|s| s.id == id).unwrap();
+    assert_eq!(s.agent_session_id.as_deref(), Some("conv-abc123"));
+}
+
 #[tokio::test]
 async fn post_activity_to_unknown_session_returns_404() {
     let h = spawn("naps-laptop").await;
@@ -1255,7 +622,6 @@ async fn delete_a_session_whose_worktree_holds_unsaved_work_returns_409_with_the
     let session = h
         .manager
         .create(CreateSessionRequest {
-            view: Default::default(),
             cwd: repo.path().to_path_buf(),
             command: "sleep 60".into(),
             env: HashMap::new(),
@@ -1265,7 +631,6 @@ async fn delete_a_session_whose_worktree_holds_unsaved_work_returns_409_with_the
                 branch: "feat/guarded".into(),
                 create_branch: true,
             }),
-            auto_approve: false,
         })
         .await
         .unwrap();
@@ -1309,7 +674,6 @@ async fn delete_with_force_ends_the_session_and_keeps_the_worktree() {
     let session = h
         .manager
         .create(CreateSessionRequest {
-            view: Default::default(),
             cwd: repo.path().to_path_buf(),
             command: "sleep 60".into(),
             env: HashMap::new(),
@@ -1319,7 +683,6 @@ async fn delete_with_force_ends_the_session_and_keeps_the_worktree() {
                 branch: "feat/guarded".into(),
                 create_branch: true,
             }),
-            auto_approve: false,
         })
         .await
         .unwrap();
@@ -1344,13 +707,11 @@ async fn attach_ws_streams_pty_bytes() {
     let session = h
         .manager
         .create(CreateSessionRequest {
-            view: Default::default(),
             cwd: "/tmp".into(),
             command: "bash --noprofile --norc".into(),
             env: HashMap::new(),
             metadata: HashMap::new(),
             worktree: None,
-            auto_approve: false,
         })
         .await
         .unwrap();
@@ -1381,39 +742,6 @@ async fn attach_ws_streams_pty_bytes() {
     assert!(saw_hello, "PTY did not echo through the attach WS");
 }
 
-#[tokio::test]
-async fn pty_routes_reject_structured_sessions_as_not_terminal() {
-    let h = spawn("naps-laptop").await;
-    let fake = FakeAcp::new();
-    let id = structured_session(&h, &fake).await;
-
-    let response = reqwest::Client::new()
-        .post(url(h.addr, &format!("/api/sessions/{id}/input")))
-        .json(&maestro_protocol::SendInputRequest {
-            text: "ignored".into(),
-            submit: false,
-        })
-        .send()
-        .await
-        .unwrap();
-    assert_eq!(response.status(), reqwest::StatusCode::CONFLICT);
-    let error: ApiError = response.json().await.unwrap();
-    assert_eq!(error.error.code, "not_terminal");
-    assert_eq!(error.error.message, "session is not a terminal session");
-
-    let error = connect_async(ws_url(h.addr, &format!("/api/attach/{id}")))
-        .await
-        .expect_err("structured session must not upgrade to a PTY socket");
-    let tokio_tungstenite::tungstenite::Error::Http(response) = error else {
-        panic!("expected an HTTP handshake rejection, got {error}");
-    };
-    assert_eq!(response.status(), reqwest::StatusCode::CONFLICT);
-    let body = response.body().as_deref().expect("ApiError response body");
-    let error: ApiError = serde_json::from_slice(body).unwrap();
-    assert_eq!(error.error.code, "not_terminal");
-    assert_eq!(error.error.message, "session is not a terminal session");
-}
-
 #[tokio::test]
 async fn attach_ws_for_unknown_session_returns_404() {
     let h = spawn("naps-laptop").await;
@@ -1447,13 +775,11 @@ async fn events_ws_sends_a_snapshot_then_streams_deltas() {
     let created = h
         .manager
         .create(CreateSessionRequest {
-            view: Default::default(),
             cwd: cwd.path().to_path_buf(),
             command: "sleep 30".into(),
             env: HashMap::new(),
             metadata: HashMap::new(),
             worktree: None,
-            auto_approve: false,
         })
         .await
         .expect("create");
@@ -1481,79 +807,6 @@ async fn events_ws_sends_a_snapshot_then_streams_deltas() {
     }
 }
 
-#[tokio::test]
-async fn events_ws_streams_structured_activity_without_hook_overrides() {
-    let h = spawn("konishi").await;
-    let fake = FakeAcp::new();
-    let mut env = fake.env();
-    env.insert("FAKE_ACP_DELAY_PROMPT_MS".into(), "500".into());
-    let (mut ws, _) = connect_async(ws_url(h.addr, "/api/events"))
-        .await
-        .expect("events ws");
-    assert!(matches!(
-        next_event(&mut ws).await,
-        maestro_protocol::CatalogEvent::Snapshot { .. }
-    ));
-
-    let id = structured_session_with_env(&h, env).await;
-    let maestro_protocol::CatalogEvent::SessionAdded { session } = next_event(&mut ws).await else {
-        panic!("expected structured SessionAdded")
-    };
-    assert_eq!(session.activity, ActivityState::Starting);
-    // The background handshake completes and sends SessionUpdated → Idle.
-    let maestro_protocol::CatalogEvent::SessionUpdated { session } = next_event(&mut ws).await
-    else {
-        panic!("expected SessionUpdated after handshake")
-    };
-    assert_eq!(session.activity, ActivityState::Idle);
-
-    let client = reqwest::Client::new();
-    let prompt = client
-        .post(url(
-            h.addr,
-            &format!("/api/sessions/{id}/structured/prompt"),
-        ))
-        .json(&serde_json::json!({"prompt": "hello"}))
-        .send()
-        .await
-        .unwrap();
-    assert_eq!(prompt.status(), reqwest::StatusCode::NO_CONTENT);
-    let report = client
-        .post(url(h.addr, &format!("/api/sessions/{id}/activity")))
-        .json(&serde_json::json!({"state": "Error"}))
-        .send()
-        .await
-        .unwrap();
-    assert_eq!(report.status(), reqwest::StatusCode::NO_CONTENT);
-    wait_for_session_activity(&h, id, ActivityState::Active).await;
-
-    let mut activities = Vec::new();
-    tokio::time::timeout(Duration::from_secs(2), async {
-        loop {
-            if let maestro_protocol::CatalogEvent::SessionUpdated { session } =
-                next_event(&mut ws).await
-            {
-                activities.push(session.activity);
-                if session.activity == ActivityState::Idle {
-                    return;
-                }
-            }
-        }
-    })
-    .await
-    .expect("structured turn returns to idle");
-    assert!(
-        activities.contains(&ActivityState::Active),
-        "{activities:?}"
-    );
-    assert!(
-        !activities.contains(&ActivityState::Error),
-        "{activities:?}"
-    );
-
-    h.manager.kill(id, false).await.unwrap();
-}
-
 /// Each subscriber has its own lag domain now that the publisher task is gone:
 /// two clients connected at different times both get their own Snapshot.
 #[tokio::test]
@@ -1566,13 +819,11 @@ async fn every_events_subscriber_gets_its_own_snapshot() {
 
     h.manager
         .create(CreateSessionRequest {
-            view: Default::default(),
             cwd: cwd.path().to_path_buf(),
             command: "sleep 30".into(),
             env: HashMap::new(),
             metadata: HashMap::new(),
             worktree: None,
-            auto_approve: false,
         })
         .await
         .expect("create");

crates/maestro-daemon/tests/rename.rs

@@ -51,13 +51,11 @@ async fn spawn_named(manager: &SessionManager, name: Option<&str>) -> Uuid {
     };
     manager
         .create(CreateSessionRequest {
-            view: Default::default(),
             cwd: "/tmp".into(),
             command: "sleep 60".into(),
             env: Default::default(),
             metadata,
             worktree: None,
-            auto_approve: false,
         })
         .await
         .unwrap()

crates/maestro-daemon/tests/resume.rs

@@ -0,0 +1,593 @@
+//! End-to-end tests for `POST /api/sessions/:id/resume` (#166) and the
+//! manager call behind it, against real tmux.
+//!
+//! The point of resume is that the session comes back under the *same* uuid
+//! and sidecar — name, `created_at`, env and worktree ownership intact — with
+//! only the tmux session and the PTY bridge new.
+
+mod common;
+
+use std::collections::HashMap;
+use std::net::{Ipv4Addr, SocketAddr};
+use std::sync::Arc;
+use std::time::Duration;
+
+use common::{wait_for_async, DaemonFixture};
+use maestro_daemon::{local_api, SessionError, SessionManager};
+use maestro_protocol::{CreateSessionRequest, Session, SessionStatus, SpawnPreset};
+use tempfile::TempDir;
+use tokio::net::TcpListener;
+use tokio::sync::oneshot;
+use uuid::Uuid;
+
+/// A fresh manager over the same tmux server, sidecars and fifos — what the
+/// daemon builds after a restart.
+fn revive(fx: &DaemonFixture) -> SessionManager {
+    SessionManager::new(
+        Arc::new(fx.tmux.tmux.clone()),
+        maestro_daemon::sidecar::SidecarStore::new(fx.sidecar_dir()),
+        maestro_daemon::worktree::WorktreeManager::new(None),
+        fx.fifo_dir(),
+    )
+}
+
+/// Create a session, then simulate the host reboot that leaves it dormant:
+/// the tmux server dies, the sidecar stays, a new manager recovers.
+async fn dormant_session(
+    fx: &DaemonFixture,
+    cwd: &TempDir,
+    command: &str,
+    name: &str,
+) -> (SessionManager, Session) {
+    let mut metadata = HashMap::new();
+    metadata.insert(
+        maestro_protocol::NAME_KEY.to_string(),
+        serde_json::Value::String(name.into()),
+    );
+    let session = fx
+        .manager
+        .create(CreateSessionRequest {
+            cwd: cwd.path().to_path_buf(),
+            command: command.into(),
+            env: HashMap::from([("MAESTRO_TEST_ENV".to_string(), "kept".to_string())]),
+            metadata,
+            worktree: None,
+        })
+        .await
+        .expect("create");
+    fx.tmux.tmux.kill_server().expect("kill tmux server");
+    let revived = revive(fx);
+    revived.recover().await.expect("recover");
+    (revived, session)
+}
+
+fn marker_preset(command: &str, marker_dir: &TempDir) -> Vec<SpawnPreset> {
+    vec![SpawnPreset {
+        id: "agent".into(),
+        label: "Agent".into(),
+        command: command.into(),
+        resume_command: Some(format!(
+            "sh -c 'touch {}/resumed-{{agent_session}}; sleep 30'",
+            marker_dir.path().display()
+        )),
+    }]
+}
+
+/// The keystone: a dormant session comes back running under its own id, with
+/// its name, `created_at`, env and sidecar untouched.
+#[tokio::test]
+async fn resume_brings_a_dormant_session_back_under_the_same_id() {
+    let fx = DaemonFixture::new();
+    let cwd = TempDir::new().unwrap();
+    let (manager, original) = dormant_session(&fx, &cwd, "sleep 30", "long-runner").await;
+    assert_eq!(
+        manager.status(original.id).await,
+        Some(SessionStatus::Dormant)
+    );
+
+    let resumed = manager.resume(original.id, &[]).await.expect("resume");
+
+    assert_eq!(resumed.id, original.id, "same uuid");
+    assert_eq!(resumed.status, SessionStatus::Running);
+    assert_eq!(resumed.created_at, original.created_at);
+    assert_eq!(resumed.cwd, original.cwd);
+    assert_eq!(resumed.command, original.command);
+    assert_eq!(resumed.env, original.env);
+    assert_eq!(
+        resumed
+            .metadata
+            .get(maestro_protocol::NAME_KEY)
+            .and_then(|v| v.as_str()),
+        Some("long-runner")
+    );
+
+    // tmux really holds it again, and the sidecar is the same file, updated.
+    let live = fx.tmux.tmux.list_sessions().expect("list");
+    assert_eq!(live, vec![original.id]);
+    let stored = maestro_daemon::sidecar::SidecarStore::new(fx.sidecar_dir())
+        .read(original.id)
+        .expect("read sidecar")
+        .expect("sidecar still there");
+    assert_eq!(stored.status, SessionStatus::Running);
+    assert_eq!(stored.created_at, original.created_at);
+
+    // And it is attachable again, which a dormant session never was.
+    assert!(manager
+        .subscribe_pty_with_replay(original.id)
+        .await
+        .is_some());
+}
+
+/// The worktree the session owns stays the session's, so killing the resumed
+/// session still cleans the tree up.
+#[tokio::test]
+async fn resume_keeps_worktree_ownership() {
+    let fx = DaemonFixture::new();
+    let repo = TempDir::new().unwrap();
+    common::init_repo(repo.path());
+
+    let session = fx
+        .manager
+        .create(CreateSessionRequest {
+            cwd: repo.path().to_path_buf(),
+            command: "sleep 30".into(),
+            env: HashMap::new(),
+            metadata: HashMap::new(),
+            worktree: Some(maestro_protocol::WorktreeSpec {
+                base_repo: repo.path().to_path_buf(),
+                branch: "feature".into(),
+                create_branch: true,
+            }),
+        })
+        .await
+        .expect("create");
+    let worktree = session.worktree.clone().expect("worktree");
+
+    fx.tmux.tmux.kill_server().expect("kill tmux server");
+    let manager = revive(&fx);
+    manager.recover().await.expect("recover");
+    let resumed = manager.resume(session.id, &[]).await.expect("resume");
+
+    assert_eq!(resumed.worktree, Some(worktree.clone()));
+    assert_eq!(
+        resumed.cwd, worktree.path,
+        "resumed inside its own worktree"
+    );
+}
+
+/// The command comes from the preset's `resume_command`, with the session's
+/// own agent conversation id (#161) substituted in.
+#[tokio::test]
+async fn resume_runs_the_presets_resume_command() {
+    let fx = DaemonFixture::new();
+    let cwd = TempDir::new().unwrap();
+    let markers = TempDir::new().unwrap();
+    let presets = marker_preset("sleep 30", &markers);
+
+    let (manager, session) = dormant_session(&fx, &cwd, "sleep 30", "agentic").await;
+    // The agent reported its conversation id before the reboot, so it is on
+    // the sidecar and the resume template can be filled in.
+    fx.manager
+        .report_activity(
+            session.id,
+            maestro_protocol::ActivityState::Idle,
+            None,
+            Some("conv-42".into()),
+        )
+        .await
+        .ok();
+    // Re-read the sidecar the report updated.
+    let manager = {
+        drop(manager);
+        let m = revive(&fx);
+        m.recover().await.expect("recover");
+        m
+    };
+
+    manager.resume(session.id, &presets).await.expect("resume");
+
+    let marker = markers.path().join("resumed-conv-42");
+    wait_for_async(Duration::from_secs(5), || {
+        let marker = marker.clone();
+        async move { marker.exists() }
+    })
+    .await;
+}
+
+/// A session that is already running has nothing to bring back, and
+/// respawning would strand the pane that is already there.
+#[tokio::test]
+async fn resume_refuses_a_running_session() {
+    let fx = DaemonFixture::new();
+    let cwd = TempDir::new().unwrap();
+    let session = fx
+        .manager
+        .create(CreateSessionRequest {
+            cwd: cwd.path().to_path_buf(),
+            command: "sleep 30".into(),
+            env: HashMap::new(),
+            metadata: HashMap::new(),
+            worktree: None,
+        })
+        .await
+        .expect("create");
+
+    let err = fx
+        .manager
+        .resume(session.id, &[])
+        .await
+        .expect_err("already running");
+    assert!(matches!(err, SessionError::AlreadyRunning(id) if id == session.id));
+    assert_eq!(err.to_error_info().code, "already_running");
+}
+
+/// Nothing can be resumed in a directory that no longer exists.
+#[tokio::test]
+async fn resume_refuses_when_the_cwd_is_gone() {
+    let fx = DaemonFixture::new();
+    let cwd = TempDir::new().unwrap();
+    let (manager, session) = dormant_session(&fx, &cwd, "sleep 30", "homeless").await;
+
+    std::fs::remove_dir_all(cwd.path()).unwrap();
+
+    let err = manager
+        .resume(session.id, &[])
+        .await
+        .expect_err("cwd is gone");
+    assert_eq!(err.to_error_info().code, "cwd_missing");
+    assert_eq!(
+        manager.status(session.id).await,
+        Some(SessionStatus::Dormant),
+        "a refused resume leaves the session exactly as it was"
+    );
+}
+
+#[tokio::test]
+async fn resume_of_an_unknown_session_is_not_found() {
+    let fx = DaemonFixture::new();
+    let err = fx
+        .manager
+        .resume(Uuid::new_v4(), &[])
+        .await
+        .expect_err("unknown");
+    assert_eq!(err.to_error_info().code, "not_found");
+}
+
+// ---------------------------------------------------------------------------
+// HTTP surface
+// ---------------------------------------------------------------------------
+
+struct Harness {
+    addr: SocketAddr,
+    _shutdown: oneshot::Sender<()>,
+}
+
+async fn serve(manager: SessionManager, presets: Vec<SpawnPreset>) -> Harness {
+    let router = local_api::router(local_api::state_for(
+        manager,
+        "test-host",
+        "/home/test",
+        presets,
+        Arc::new(maestro_daemon::projects::ProjectScanner::disabled()),
+        maestro_config::DEFAULT_LEADER,
+    ));
+    let listener = TcpListener::bind(SocketAddr::from((Ipv4Addr::LOCALHOST, 0)))
+        .await
+        .unwrap();
+    let addr = listener.local_addr().unwrap();
+    let (tx, rx) = oneshot::channel::<()>();
+    tokio::spawn(async move {
+        let _ = axum::serve(listener, router)
+            .with_graceful_shutdown(async move {
+                let _ = rx.await;
+            })
+            .await;
+    });
+    Harness {
+        addr,
+        _shutdown: tx,
+    }
+}
+
+#[tokio::test]
+async fn post_resume_returns_the_revived_session() {
+    let fx = DaemonFixture::new();
+    let cwd = TempDir::new().unwrap();
+    let (manager, session) = dormant_session(&fx, &cwd, "sleep 30", "web-resumed").await;
+    let h = serve(manager, Vec::new()).await;
+
+    let resp = reqwest::Client::new()
+        .post(format!(
+            "http://{}{}",
+            h.addr,
+            maestro_protocol::routes::session_resume(session.id)
+        ))
+        .send()
+        .await
+        .unwrap();
+    assert_eq!(resp.status(), reqwest::StatusCode::OK);
+    let body: Session = resp.json().await.unwrap();
+    assert_eq!(body.id, session.id);
+    assert_eq!(body.status, SessionStatus::Running);
+}
+
+#[tokio::test]
+async fn post_resume_on_a_running_session_is_a_conflict() {
+    let fx = DaemonFixture::new();
+    let cwd = TempDir::new().unwrap();
+    let session = fx
+        .manager
+        .create(CreateSessionRequest {
+            cwd: cwd.path().to_path_buf(),
+            command: "sleep 30".into(),
+            env: HashMap::new(),
+            metadata: HashMap::new(),
+            worktree: None,
+        })
+        .await
+        .expect("create");
+    let h = serve(fx.manager.clone(), Vec::new()).await;
+
+    let resp = reqwest::Client::new()
+        .post(format!(
+            "http://{}{}",
+            h.addr,
+            maestro_protocol::routes::session_resume(session.id)
+        ))
+        .send()
+        .await
+        .unwrap();
+    assert_eq!(resp.status(), reqwest::StatusCode::CONFLICT);
+    let err: maestro_protocol::ApiError = resp.json().await.unwrap();
+    assert_eq!(err.error.code, "already_running");
+}
+
+#[tokio::test]
+async fn post_resume_on_an_unknown_session_is_404() {
+    let fx = DaemonFixture::new();
+    let h = serve(fx.manager.clone(), Vec::new()).await;
+    let resp = reqwest::Client::new()
+        .post(format!(
+            "http://{}{}",
+            h.addr,
+            maestro_protocol::routes::session_resume(Uuid::new_v4())
+        ))
+        .send()
+        .await
+        .unwrap();
+    assert_eq!(resp.status(), reqwest::StatusCode::NOT_FOUND);
+}
+
+// ---------------------------------------------------------------------------
+// Races (#175)
+// ---------------------------------------------------------------------------
+
+/// Real tmux, with the *first* `new_session_piped` held inside the call until
+/// the test releases it. Later calls pass straight through, so a second resume
+/// racing the first never blocks on a gate the first one owns.
+///
+/// This is what makes the two races below deterministic rather than timing
+/// dependent: the resume under test is parked in exactly the window the bug
+/// lives in, and the racing operation runs to completion before it moves.
+#[derive(Debug)]
+struct GatedSpawn {
+    inner: maestro_daemon::tmux::Tmux,
+    entered: tokio::sync::mpsc::UnboundedSender<()>,
+    release: std::sync::Mutex<std::sync::mpsc::Receiver<()>>,
+    gated: std::sync::atomic::AtomicBool,
+}
+
+/// The test's end of a [`GatedSpawn`].
+struct Gate {
+    entered: tokio::sync::mpsc::UnboundedReceiver<()>,
+    release: std::sync::mpsc::SyncSender<()>,
+}
+
+impl Gate {
+    /// Wait until the gated spawn is parked mid-resume.
+    async fn wait_entered(&mut self) {
+        tokio::time::timeout(Duration::from_secs(10), self.entered.recv())
+            .await
+            .expect("resume reached the tmux spawn")
+            .expect("gate alive");
+    }
+
+    fn release(&self) {
+        self.release.send(()).expect("gate receiver alive");
+    }
+}
+
+fn gated_panes(inner: maestro_daemon::tmux::Tmux) -> (Arc<GatedSpawn>, Gate) {
+    let (entered_tx, entered_rx) = tokio::sync::mpsc::unbounded_channel();
+    let (release_tx, release_rx) = std::sync::mpsc::sync_channel(1);
+    (
+        Arc::new(GatedSpawn {
+            inner,
+            entered: entered_tx,
+            release: std::sync::Mutex::new(release_rx),
+            gated: std::sync::atomic::AtomicBool::new(true),
+        }),
+        Gate {
+            entered: entered_rx,
+            release: release_tx,
+        },
+    )
+}
+
+impl maestro_daemon::panes::Panes for GatedSpawn {
+    fn new_session_piped(
+        &self,
+        id: Uuid,
+        cwd: &std::path::Path,
+        command: &str,
+        session_env: &std::collections::BTreeMap<String, String>,
+        sink_command: &str,
+    ) -> Result<(), maestro_daemon::tmux::TmuxError> {
+        if self.gated.swap(false, std::sync::atomic::Ordering::SeqCst) {
+            let _ = self.entered.send(());
+            let _ = self.release.lock().expect("gate mutex").recv();
+        }
+        self.inner
+            .new_session_piped(id, cwd, command, session_env, sink_command)
+    }
+
+    fn kill_session(&self, id: Uuid) -> Result<(), maestro_daemon::tmux::TmuxError> {
+        self.inner.kill_session(id)
+    }
+
+    fn list_sessions(&self) -> Result<Vec<Uuid>, maestro_daemon::tmux::TmuxError> {
+        self.inner.list_sessions()
+    }
+
+    fn pane_info(
+        &self,
+        id: Uuid,
+    ) -> Result<Option<maestro_daemon::tmux::PaneInfo>, maestro_daemon::tmux::TmuxError> {
+        self.inner.pane_info(id)
+    }
+
+    fn send_keys(&self, id: Uuid, bytes: &[u8]) -> Result<(), maestro_daemon::tmux::TmuxError> {
+        self.inner.send_keys(id, bytes)
+    }
+
+    fn pipe_pane(&self, id: Uuid, sink: &str) -> Result<(), maestro_daemon::tmux::TmuxError> {
+        self.inner.pipe_pane(id, sink)
+    }
+
+    fn resize_window(
+        &self,
+        id: Uuid,
+        cols: u16,
+        rows: u16,
+    ) -> Result<(), maestro_daemon::tmux::TmuxError> {
+        self.inner.resize_window(id, cols, rows)
+    }
+
+    fn capture_pane(&self, id: Uuid) -> Result<Option<Vec<u8>>, maestro_daemon::tmux::TmuxError> {
+        self.inner.capture_pane(id)
+    }
+}
+
+/// A dormant session whose manager's tmux spawn can be parked by the test.
+async fn dormant_gated(fx: &DaemonFixture, cwd: &TempDir) -> (SessionManager, Session, Gate) {
+    let session = fx
+        .manager
+        .create(CreateSessionRequest {
+            cwd: cwd.path().to_path_buf(),
+            command: "sleep 30".into(),
+            env: HashMap::new(),
+            metadata: HashMap::new(),
+            worktree: None,
+        })
+        .await
+        .expect("create");
+    fx.tmux.tmux.kill_server().expect("kill tmux server");
+
+    let (panes, gate) = gated_panes(fx.tmux.tmux.clone());
+    let manager = SessionManager::new(
+        panes,
+        maestro_daemon::sidecar::SidecarStore::new(fx.sidecar_dir()),
+        maestro_daemon::worktree::WorktreeManager::new(None),
+        fx.fifo_dir(),
+    );
+    manager.recover().await.expect("recover");
+    assert_eq!(
+        manager.status(session.id).await,
+        Some(SessionStatus::Dormant)
+    );
+    (manager, session, gate)
+}
+
+/// A kill that lands while a resume is inside the tmux spawn must not leave
+/// the sidecar behind. The kill deletes it; the resume writes it back a moment
+/// later and then discovers its own record is gone. The sidecar it resurrected
+/// would otherwise make the next recovery register a ghost dormant session for
+/// a session that was killed.
+#[tokio::test]
+async fn a_kill_during_resume_leaves_no_sidecar_behind() {
+    let fx = DaemonFixture::new();
+    let cwd = TempDir::new().unwrap();
+    let (manager, session, mut gate) = dormant_gated(&fx, &cwd).await;
+    let id = session.id;
+
+    let resuming = tokio::spawn({
+        let manager = manager.clone();
+        async move { manager.resume(id, &[]).await }
+    });
+    gate.wait_entered().await;
+
+    manager.kill(id, false).await.expect("kill mid-resume");
+    gate.release();
+
+    let err = resuming.await.unwrap().expect_err("record is gone");
+    assert!(matches!(err, SessionError::NotFound(got) if got == id));
+
+    assert!(
+        maestro_daemon::sidecar::SidecarStore::new(fx.sidecar_dir())
+            .read(id)
+            .expect("read sidecar")
+            .is_none(),
+        "the killed session's sidecar must not be resurrected by the losing resume"
+    );
+
+    // And so the next recovery registers no ghost.
+    let after = revive(&fx);
+    after.recover().await.expect("recover");
+    assert!(
+        after.snapshot().await.is_empty(),
+        "a killed session must not come back dormant"
+    );
+}
+
+/// Two resumes of the same session must not both proceed. The second is
+/// refused on the state — `already_running` — not on its tmux spawn colliding
+/// with the first one's.
+#[tokio::test]
+async fn a_second_resume_is_refused_while_the_first_is_in_flight() {
+    let fx = DaemonFixture::new();
+    let cwd = TempDir::new().unwrap();
+    let (manager, session, mut gate) = dormant_gated(&fx, &cwd).await;
+    let id = session.id;
+
+    let resuming = tokio::spawn({
+        let manager = manager.clone();
+        async move { manager.resume(id, &[]).await }
+    });
+    gate.wait_entered().await;
+
+    let err = manager
+        .resume(id, &[])
+        .await
+        .expect_err("a resume is already in flight");
+    assert!(matches!(err, SessionError::AlreadyRunning(got) if got == id));
+    assert_eq!(err.to_error_info().code, "already_running");
+
+    gate.release();
+    let first = resuming.await.unwrap().expect("the first resume wins");
+    assert_eq!(first.status, SessionStatus::Running);
+    assert_eq!(
+        fx.tmux.tmux.list_sessions().expect("list"),
+        vec![id],
+        "exactly one pane for the session"
+    );
+}
+
+/// A refused resume must not leave the session marked in-flight: once the
+/// reason for the refusal is gone, resuming works.
+#[tokio::test]
+async fn a_refused_resume_can_be_retried() {
+    let fx = DaemonFixture::new();
+    let cwd = TempDir::new().unwrap();
+    let (manager, session) = dormant_session(&fx, &cwd, "sleep 30", "retried").await;
+
+    std::fs::remove_dir_all(cwd.path()).unwrap();
+    let err = manager
+        .resume(session.id, &[])
+        .await
+        .expect_err("cwd is gone");
+    assert_eq!(err.to_error_info().code, "cwd_missing");
+
+    std::fs::create_dir_all(cwd.path()).unwrap();
+    let resumed = manager.resume(session.id, &[]).await.expect("resume");
+    assert_eq!(resumed.status, SessionStatus::Running);
+}

crates/maestro-daemon/tests/resume_policy.rs

@@ -0,0 +1,161 @@
+//! `[daemon].resume_on_boot` (#167): what recovery does with sessions whose
+//! tmux pane is gone but whose sidecar survived, against real tmux.
+//!
+//! The default is deliberately the timid one. Resuming agents unattended
+//! seconds after a reboot is a foot-gun, so `auto` is opted into per host and
+//! `never` throws the sidecars away instead.
+
+mod common;
+
+use std::collections::HashMap;
+use std::sync::Arc;
+use std::time::Duration;
+
+use common::{wait_for_async, DaemonFixture};
+use maestro_config::ResumeOnBoot;
+use maestro_daemon::SessionManager;
+use maestro_protocol::{CreateSessionRequest, Session, SessionStatus, SpawnPreset};
+use tempfile::TempDir;
+
+/// A fresh manager over the same tmux server, sidecars and fifos — what the
+/// daemon builds after a restart — carrying `policy`.
+fn revive(fx: &DaemonFixture, policy: ResumeOnBoot, presets: Vec<SpawnPreset>) -> SessionManager {
+    SessionManager::new(
+        Arc::new(fx.tmux.tmux.clone()),
+        maestro_daemon::sidecar::SidecarStore::new(fx.sidecar_dir()),
+        maestro_daemon::worktree::WorktreeManager::new(None),
+        fx.fifo_dir(),
+    )
+    .with_resume_policy(policy, presets)
+}
+
+/// A preset whose `resume_command` touches a marker file, so a test can see
+/// that the resumed session ran the resume command rather than the original.
+fn marker_preset(command: &str, marker_dir: &TempDir) -> Vec<SpawnPreset> {
+    vec![SpawnPreset {
+        id: "agent".into(),
+        label: "Agent".into(),
+        command: command.into(),
+        resume_command: Some(format!(
+            "sh -c 'touch {}/resumed; sleep 30'",
+            marker_dir.path().display()
+        )),
+    }]
+}
+
+async fn create(fx: &DaemonFixture, cwd: &TempDir, command: &str) -> Session {
+    fx.manager
+        .create(CreateSessionRequest {
+            cwd: cwd.path().to_path_buf(),
+            command: command.into(),
+            env: HashMap::new(),
+            metadata: HashMap::new(),
+            worktree: None,
+        })
+        .await
+        .expect("create")
+}
+
+/// The default: a reboot leaves the session listed but not running, waiting
+/// for the operator.
+#[tokio::test]
+async fn dormant_is_the_default_and_leaves_the_session_waiting() {
+    let fx = DaemonFixture::new();
+    let cwd = TempDir::new().unwrap();
+    let session = create(&fx, &cwd, "sleep 30").await;
+    fx.tmux.tmux.kill_server().expect("kill tmux server");
+
+    let revived = revive(&fx, ResumeOnBoot::Dormant, Vec::new());
+    revived.recover().await.expect("recover");
+
+    assert_eq!(
+        revived.status(session.id).await,
+        Some(SessionStatus::Dormant)
+    );
+    assert!(fx
+        .sidecar_dir()
+        .join(format!("{}.json", session.id))
+        .exists());
+    assert!(
+        fx.tmux.tmux.list_sessions().expect("list").is_empty(),
+        "nothing was respawned"
+    );
+}
+
+/// `auto` brings each one back itself, down the same path a client's resume
+/// takes: same uuid, same sidecar, the preset's `resume_command`.
+#[tokio::test]
+async fn auto_resumes_every_dormant_session_during_recovery() {
+    let fx = DaemonFixture::new();
+    let cwd = TempDir::new().unwrap();
+    let markers = TempDir::new().unwrap();
+    let session = create(&fx, &cwd, "sleep 30").await;
+    fx.tmux.tmux.kill_server().expect("kill tmux server");
+
+    let revived = revive(&fx, ResumeOnBoot::Auto, marker_preset("sleep 30", &markers));
+    revived.recover().await.expect("recover");
+
+    assert_eq!(
+        revived.status(session.id).await,
+        Some(SessionStatus::Running),
+        "auto resumed it"
+    );
+    assert_eq!(
+        fx.tmux.tmux.list_sessions().expect("list"),
+        vec![session.id],
+        "back under the same uuid"
+    );
+    let stored = maestro_daemon::sidecar::SidecarStore::new(fx.sidecar_dir())
+        .read(session.id)
+        .expect("read sidecar")
+        .expect("same sidecar");
+    assert_eq!(stored.created_at, session.created_at);
+    assert_eq!(stored.command, "sleep 30", "the original command is kept");
+
+    // It really ran the preset's resume command, not the spawn command.
+    let marker = markers.path().join("resumed");
+    wait_for_async(Duration::from_secs(5), || {
+        let marker = marker.clone();
+        async move { marker.exists() }
+    })
+    .await;
+    assert!(marker.exists(), "resume_command ran");
+}
+
+/// `never` makes a reboot a clean slate: the sidecars go, and the session is
+/// not listed at all.
+#[tokio::test]
+async fn never_prunes_the_sidecars_instead() {
+    let fx = DaemonFixture::new();
+    let cwd = TempDir::new().unwrap();
+    let session = create(&fx, &cwd, "sleep 30").await;
+    fx.tmux.tmux.kill_server().expect("kill tmux server");
+
+    let revived = revive(&fx, ResumeOnBoot::Never, Vec::new());
+    revived.recover().await.expect("recover");
+
+    assert!(!revived.has(session.id).await, "not listed");
+    assert!(
+        !fx.sidecar_dir()
+            .join(format!("{}.json", session.id))
+            .exists(),
+        "sidecar pruned"
+    );
+    assert!(fx.tmux.tmux.list_sessions().expect("list").is_empty());
+}
+
+/// The policy only decides what happens to sessions that lost their pane. A
+/// session tmux still holds is adopted running by the first pass under every
+/// policy — including `never`, which must not delete a live session's sidecar.
+#[tokio::test]
+async fn the_policy_leaves_sessions_tmux_still_holds_alone() {
+    let fx = DaemonFixture::new();
+    let cwd = TempDir::new().unwrap();
+    let live = create(&fx, &cwd, "sleep 30").await;
+
+    let revived = revive(&fx, ResumeOnBoot::Never, Vec::new());
+    assert_eq!(revived.recover().await.expect("recover"), 1);
+
+    assert_eq!(revived.status(live.id).await, Some(SessionStatus::Running));
+    assert!(fx.sidecar_dir().join(format!("{}.json", live.id)).exists());
+}

crates/maestro-daemon/tests/scrollback.rs

@@ -0,0 +1,219 @@
+//! Persisted PTY scrollback across a reboot (#171), against real tmux.
+//!
+//! Everything else in the reboot milestone restores what a session *is*; this
+//! restores what it *looked like*. The cases that matter are the ones a clean
+//! shutdown never gets to run: the host went down, and the only scrollback
+//! that exists is whatever the last periodic flush wrote.
+
+mod common;
+
+use std::collections::HashMap;
+use std::sync::Arc;
+use std::time::Duration;
+
+use common::{wait_for_async, DaemonFixture};
+use maestro_daemon::scrollback::ScrollbackStore;
+use maestro_daemon::SessionManager;
+use maestro_protocol::{CreateSessionRequest, Session, SessionStatus};
+use tempfile::TempDir;
+use uuid::Uuid;
+
+/// A fresh manager over the same tmux server, sidecars, fifos and scrollback —
+/// what the daemon builds after a restart.
+fn revive(fx: &DaemonFixture) -> SessionManager {
+    SessionManager::new(
+        Arc::new(fx.tmux.tmux.clone()),
+        maestro_daemon::sidecar::SidecarStore::new(fx.sidecar_dir()),
+        maestro_daemon::worktree::WorktreeManager::new(None),
+        fx.fifo_dir(),
+    )
+    .with_scrollback(fx.scrollback_dir())
+}
+
+async fn spawn(fx: &DaemonFixture, cwd: &TempDir, command: &str) -> Session {
+    fx.manager
+        .create(CreateSessionRequest {
+            cwd: cwd.path().to_path_buf(),
+            command: command.into(),
+            env: HashMap::new(),
+            metadata: HashMap::new(),
+            worktree: None,
+        })
+        .await
+        .expect("create")
+}
+
+/// Wait until the session has printed `needle`, flushing as we go — the same
+/// thing the liveness watcher's flush pass does on its timer.
+async fn wait_for_flushed(
+    manager: &SessionManager,
+    store: &ScrollbackStore,
+    id: Uuid,
+    needle: &str,
+) {
+    wait_for_async(Duration::from_secs(10), || async {
+        manager.flush_scrollback().await;
+        String::from_utf8_lossy(&store.read(id, 64 * 1024)).contains(needle)
+    })
+    .await;
+}
+
+fn replay_text(replay: &[u8]) -> String {
+    String::from_utf8_lossy(replay).to_string()
+}
+
+/// The keystone: the host reboots with no exit path run at all, and the
+/// resumed session opens showing what it printed before.
+#[tokio::test]
+async fn a_resumed_session_replays_the_scrollback_from_before_the_reboot() {
+    let fx = DaemonFixture::new();
+    let cwd = TempDir::new().unwrap();
+    let store = ScrollbackStore::new(fx.scrollback_dir());
+
+    let session = spawn(&fx, &cwd, "sh -c 'echo before-the-reboot; sleep 30'").await;
+    wait_for_flushed(&fx.manager, &store, session.id, "before-the-reboot").await;
+
+    // The reboot: tmux dies where it stands. No kill, no seal, no shutdown
+    // hook — only whatever the periodic flush had already written.
+    fx.tmux.tmux.kill_server().expect("kill tmux server");
+    let manager = revive(&fx);
+    manager.recover().await.expect("recover");
+    assert_eq!(
+        manager.status(session.id).await,
+        Some(SessionStatus::Dormant)
+    );
+
+    manager.resume(session.id, &[]).await.expect("resume");
+    let (replay, _rx) = manager
+        .subscribe_pty_with_replay(session.id)
+        .await
+        .expect("attachable again");
+    assert!(
+        replay_text(&replay).contains("before-the-reboot"),
+        "resumed pane should open on the old scrollback, got {:?}",
+        replay_text(&replay)
+    );
+}
+
+/// A daemon restart leaves tmux alone, so the session is adopted rather than
+/// resumed — and it too lost its in-memory ring with the old process.
+#[tokio::test]
+async fn an_adopted_session_replays_the_scrollback_of_the_previous_daemon() {
+    let fx = DaemonFixture::new();
+    let cwd = TempDir::new().unwrap();
+    let store = ScrollbackStore::new(fx.scrollback_dir());
+
+    let session = spawn(&fx, &cwd, "sh -c 'echo printed-earlier; sleep 30'").await;
+    wait_for_flushed(&fx.manager, &store, session.id, "printed-earlier").await;
+
+    // Daemon restart: the manager goes, tmux stays.
+    let manager = revive(&fx);
+    manager.recover().await.expect("recover");
+    assert_eq!(
+        manager.status(session.id).await,
+        Some(SessionStatus::Running)
+    );
+
+    let (replay, _rx) = manager
+        .subscribe_pty_with_replay(session.id)
+        .await
+        .expect("attachable");
+    assert!(
+        replay_text(&replay).contains("printed-earlier"),
+        "adopted pane should carry the old scrollback ahead of tmux's screen, got {:?}",
+        replay_text(&replay)
+    );
+}
+
+/// Killing a session takes its scrollback with it: nothing will ever read the
+/// file again, and the operator's output should not linger on disk.
+#[tokio::test]
+async fn killing_a_session_deletes_its_scrollback() {
+    let fx = DaemonFixture::new();
+    let cwd = TempDir::new().unwrap();
+    let store = ScrollbackStore::new(fx.scrollback_dir());
+
+    let session = spawn(&fx, &cwd, "sh -c 'echo doomed; sleep 30'").await;
+    wait_for_flushed(&fx.manager, &store, session.id, "doomed").await;
+    assert!(store.path_for(session.id).exists());
+
+    fx.manager.kill(session.id, false).await.expect("kill");
+    assert!(
+        !store.path_for(session.id).exists(),
+        "scrollback should not outlive the session"
+    );
+}
+
+/// A session that exits on its own does get an exit path, and takes it: the
+/// last thing it printed is flushed when the bridge is sealed, with no wait
+/// for the next tick.
+#[tokio::test]
+async fn a_session_that_exits_flushes_its_last_output() {
+    let fx = DaemonFixture::new();
+    let cwd = TempDir::new().unwrap();
+    let store = ScrollbackStore::new(fx.scrollback_dir());
+
+    let session = spawn(&fx, &cwd, "sh -c 'echo last-words'").await;
+    fx.manager
+        .start_liveness_watcher(Duration::from_millis(100));
+    wait_for_async(Duration::from_secs(10), || async {
+        fx.manager.status(session.id).await == Some(SessionStatus::Dead)
+    })
+    .await;
+
+    assert!(
+        String::from_utf8_lossy(&store.read(session.id, 64 * 1024)).contains("last-words"),
+        "a sealed bridge should have flushed what it printed"
+    );
+}
+
+/// Nothing here may fail a resume. A scrollback file that is gone, or one full
+/// of bytes no terminal would emit, degrades to a pane with no history — not
+/// to an error.
+#[tokio::test]
+async fn a_missing_or_corrupt_scrollback_still_resumes() {
+    let fx = DaemonFixture::new();
+    let cwd = TempDir::new().unwrap();
+    let store = ScrollbackStore::new(fx.scrollback_dir());
+
+    let gone = spawn(&fx, &cwd, "sleep 30").await;
+    let garbled = spawn(&fx, &cwd, "sleep 30").await;
+    fx.manager.flush_scrollback().await;
+
+    fx.tmux.tmux.kill_server().expect("kill tmux server");
+    std::fs::create_dir_all(store.dir()).expect("scrollback dir");
+    std::fs::remove_file(store.path_for(gone.id)).ok();
+    std::fs::write(store.path_for(garbled.id), [0xff, 0xfe, 0x00, 0x80]).expect("write garbage");
+
+    let manager = revive(&fx);
+    manager.recover().await.expect("recover");
+    for id in [gone.id, garbled.id] {
+        manager.resume(id, &[]).await.expect("resume");
+        assert_eq!(manager.status(id).await, Some(SessionStatus::Running));
+        assert!(manager.subscribe_pty_with_replay(id).await.is_some());
+    }
+}
+
+/// The disk cost is the replay budget, not a second one of its own.
+#[tokio::test]
+async fn the_flushed_file_stays_inside_the_replay_budget() {
+    let fx = DaemonFixture::new_with_replay(256);
+    let cwd = TempDir::new().unwrap();
+    let store = ScrollbackStore::new(fx.scrollback_dir());
+
+    let session = spawn(
+        &fx,
+        &cwd,
+        "sh -c 'for i in $(seq 1 400); do echo line-$i; done; sleep 30'",
+    )
+    .await;
+    wait_for_flushed(&fx.manager, &store, session.id, "line-400").await;
+
+    let size = std::fs::metadata(store.path_for(session.id))
+        .expect("stat scrollback")
+        .len();
+    assert!(
+        size <= 256,
+        "scrollback file was {size} bytes, budget is 256"
+    );
+}

crates/maestro-daemon/tests/session_decisions.rs

@@ -64,13 +64,11 @@ impl Fx {
 
     fn request(&self, command: &str) -> CreateSessionRequest {
         CreateSessionRequest {
-            view: Default::default(),
             cwd: self.tmp.path().to_path_buf(),
             command: command.into(),
             env: HashMap::new(),
             metadata: HashMap::new(),
             worktree: None,
-            auto_approve: false,
         }
     }
 }

crates/maestro-daemon/tests/session_manager.rs

@@ -9,6 +9,7 @@ use std::sync::Arc;
 use std::time::Duration;
 
 use common::{init_bare_repo, init_repo, push_all_to_origin, wait_for_async, DaemonFixture};
+use maestro_daemon::sidecar::SidecarStore;
 use maestro_daemon::SessionError;
 use maestro_protocol::CreateSessionRequest;
 use maestro_protocol::{CatalogEvent, SessionStatus, WorktreeSpec};
@@ -22,13 +23,11 @@ async fn create_then_kill_round_trip() {
     let session = fx
         .manager
         .create(CreateSessionRequest {
-            view: Default::default(),
             cwd: cwd.path().to_path_buf(),
             command: "sleep 30".into(),
             env: HashMap::new(),
             metadata: HashMap::new(),
             worktree: None,
-            auto_approve: false,
         })
         .await
         .expect("create");
@@ -65,13 +64,11 @@ async fn create_appends_to_spawn_history() {
     let session = fx
         .manager
         .create(CreateSessionRequest {
-            view: Default::default(),
             cwd: cwd.path().to_path_buf(),
             command: "sleep 30".into(),
             env: HashMap::new(),
             metadata: HashMap::from([("name".into(), serde_json::json!("neon-drifter"))]),
             worktree: None,
-            auto_approve: false,
         })
         .await
         .expect("create");
@@ -96,13 +93,11 @@ async fn create_without_history_logs_nothing() {
     let cwd = TempDir::new().unwrap();
     fx.manager
         .create(CreateSessionRequest {
-            view: Default::default(),
             cwd: cwd.path().to_path_buf(),
             command: "sleep 30".into(),
             env: HashMap::new(),
             metadata: HashMap::new(),
             worktree: None,
-            auto_approve: false,
         })
         .await
         .expect("create");
@@ -120,13 +115,11 @@ async fn recover_adopts_existing_tmux_sessions() {
     let s = fx
         .manager
         .create(CreateSessionRequest {
-            view: Default::default(),
             cwd: cwd.path().to_path_buf(),
             command: "sleep 30".into(),
             env: HashMap::new(),
             metadata: HashMap::new(),
             worktree: None,
-            auto_approve: false,
         })
         .await
         .expect("create");
@@ -148,6 +141,390 @@ async fn recover_adopts_existing_tmux_sessions() {
     assert_eq!(snap[0].command, "sleep 30");
 }
 
+/// #162: a host reboot kills the tmux server, so recovery finds nothing to
+/// adopt while every sidecar is still on disk. Those sessions come back as
+/// `Dormant` — a record of what was running — rather than vanishing from the
+/// API and leaving the operator with nothing.
+#[tokio::test]
+async fn recover_registers_orphaned_sidecars_as_dormant() {
+    let fx = DaemonFixture::new();
+    let cwd = TempDir::new().unwrap();
+    let mut metadata = HashMap::new();
+    metadata.insert(
+        maestro_protocol::NAME_KEY.to_string(),
+        serde_json::Value::String("after-reboot".into()),
+    );
+
+    let s = fx
+        .manager
+        .create(CreateSessionRequest {
+            cwd: cwd.path().to_path_buf(),
+            command: "sleep 30".into(),
+            env: HashMap::new(),
+            metadata,
+            worktree: None,
+        })
+        .await
+        .expect("create");
+
+    // The reboot: the tmux server is gone, the sidecar is untouched.
+    fx.tmux.tmux.kill_server().expect("kill tmux server");
+
+    let revived = revive(&fx);
+    let adopted = revived.recover().await.expect("recover");
+    assert_eq!(adopted, 0, "no live tmux session left to adopt");
+
+    let snap = revived.snapshot().await;
+    assert_eq!(snap.len(), 1, "the sidecar's session is still listed");
+    assert_eq!(snap[0].id, s.id);
+    assert_eq!(snap[0].status, SessionStatus::Dormant);
+    assert_eq!(snap[0].command, "sleep 30");
+    assert_eq!(snap[0].cwd, s.cwd);
+    assert_eq!(snap[0].created_at, s.created_at);
+    assert_eq!(
+        snap[0]
+            .metadata
+            .get(maestro_protocol::NAME_KEY)
+            .and_then(|v| v.as_str()),
+        Some("after-reboot"),
+    );
+}
+
+/// #162: a session tmux still holds is adopted `Running` by the first pass and
+/// must not be re-registered as dormant by the second — the sidecar is on disk
+/// for both.
+#[tokio::test]
+async fn recover_does_not_mark_adopted_sessions_dormant() {
+    let fx = DaemonFixture::new();
+    let cwd = TempDir::new().unwrap();
+
+    let live = fx
+        .manager
+        .create(CreateSessionRequest {
+            cwd: cwd.path().to_path_buf(),
+            command: "sleep 30".into(),
+            env: HashMap::new(),
+            metadata: HashMap::new(),
+            worktree: None,
+        })
+        .await
+        .expect("create live");
+    let orphan = fx
+        .manager
+        .create(CreateSessionRequest {
+            cwd: cwd.path().to_path_buf(),
+            command: "sleep 31".into(),
+            env: HashMap::new(),
+            metadata: HashMap::new(),
+            worktree: None,
+        })
+        .await
+        .expect("create orphan");
+    // Only the second session loses its pane.
+    fx.tmux.tmux.kill_session(orphan.id).expect("kill session");
+
+    let revived = revive(&fx);
+    assert_eq!(revived.recover().await.expect("recover"), 1);
+
+    let mut snap = revived.snapshot().await;
+    snap.sort_by_key(|s| s.command.clone());
+    assert_eq!(snap.len(), 2);
+    assert_eq!(snap[0].id, live.id);
+    assert_eq!(snap[0].status, SessionStatus::Running);
+    assert_eq!(snap[1].id, orphan.id);
+    assert_eq!(snap[1].status, SessionStatus::Dormant);
+}
+
+/// #163: a sidecar whose `cwd` no longer exists is pruned instead of
+/// registered dormant — the worktree it pointed at is gone, so there is
+/// nothing left to resume.
+#[tokio::test]
+async fn recover_deletes_sidecar_when_cwd_gone() {
+    let fx = DaemonFixture::new();
+    let cwd = TempDir::new().unwrap();
+    let cwd_path = cwd.path().to_path_buf();
+
+    let s = fx
+        .manager
+        .create(CreateSessionRequest {
+            cwd: cwd_path.clone(),
+            command: "sleep 30".into(),
+            env: HashMap::new(),
+            metadata: HashMap::new(),
+            worktree: None,
+        })
+        .await
+        .expect("create");
+
+    fx.tmux.tmux.kill_server().expect("kill tmux server");
+    drop(cwd);
+    std::fs::remove_dir_all(&cwd_path).ok();
+    assert!(!cwd_path.exists());
+
+    let revived = revive(&fx);
+    let adopted = revived.recover().await.expect("recover");
+    assert_eq!(adopted, 0);
+
+    assert!(!revived.has(s.id).await);
+    assert!(!fx.sidecar_dir().join(format!("{}.json", s.id)).exists());
+}
+
+/// #163: a sidecar whose `cwd` still exists is left alone regardless of age
+/// — it is registered dormant like any other orphan.
+#[tokio::test]
+async fn recover_keeps_dormant_sidecar_when_cwd_exists() {
+    let fx = DaemonFixture::new();
+    let cwd = TempDir::new().unwrap();
+
+    let s = fx
+        .manager
+        .create(CreateSessionRequest {
+            cwd: cwd.path().to_path_buf(),
+            command: "sleep 30".into(),
+            env: HashMap::new(),
+            metadata: HashMap::new(),
+            worktree: None,
+        })
+        .await
+        .expect("create");
+    fx.tmux.tmux.kill_server().expect("kill tmux server");
+
+    let revived = revive(&fx);
+    revived.recover().await.expect("recover");
+
+    assert!(revived.has(s.id).await);
+    assert!(fx.sidecar_dir().join(format!("{}.json", s.id)).exists());
+    let snap = revived.snapshot().await;
+    assert_eq!(snap[0].status, SessionStatus::Dormant);
+}
+
+/// #164: a fake [`maestro_daemon::boot_id::BootIdSource`] lets tests simulate
+/// a changed (or unreadable) boot id without rebooting the machine.
+#[derive(Debug)]
+struct FakeBootId(Option<String>);
+
+impl maestro_daemon::boot_id::BootIdSource for FakeBootId {
+    fn current(&self) -> Option<String> {
+        self.0.clone()
+    }
+}
+
+fn revive_with_boot_id(
+    fx: &DaemonFixture,
+    boot_id_path: PathBuf,
+    current: Option<&str>,
+) -> maestro_daemon::SessionManager {
+    maestro_daemon::SessionManager::new(
+        Arc::new(fx.tmux.tmux.clone()),
+        maestro_daemon::sidecar::SidecarStore::new(fx.sidecar_dir()),
+        maestro_daemon::worktree::WorktreeManager::new(None),
+        fx.fifo_dir(),
+    )
+    .with_boot_id(
+        boot_id_path,
+        Arc::new(FakeBootId(current.map(String::from))),
+    )
+}
+
+/// #174: a boot id can change without the tmux server dying — a restored
+/// state directory, a VM or container snapshot restore, a truncated
+/// `boot_id` file. `tmux list-sessions` stays the single source of truth for
+/// liveness, so a session tmux still holds is adopted `Running` no matter
+/// what the boot id says. Registering it dormant instead stranded it: resume
+/// would collide with the tmux name still in use and fail forever.
+#[tokio::test]
+async fn recover_adopts_live_session_when_boot_id_changed() {
+    let fx = DaemonFixture::new();
+    let cwd = TempDir::new().unwrap();
+    let s = fx
+        .manager
+        .create(CreateSessionRequest {
+            cwd: cwd.path().to_path_buf(),
+            command: "sleep 30".into(),
+            env: HashMap::new(),
+            metadata: HashMap::new(),
+            worktree: None,
+        })
+        .await
+        .expect("create");
+
+    let boot_id_path = fx.state_dir.path().join("boot_id");
+    std::fs::write(&boot_id_path, "previous-boot").unwrap();
+
+    // tmux session is still alive: the probe runs and finds it.
+    let revived = revive_with_boot_id(&fx, boot_id_path.clone(), Some("current-boot"));
+    let adopted = revived.recover().await.expect("recover");
+    assert_eq!(adopted, 1, "tmux still holds the session; adopt it");
+
+    let snap = revived.snapshot().await;
+    assert_eq!(snap.len(), 1);
+    assert_eq!(snap[0].id, s.id);
+    assert_eq!(snap[0].status, SessionStatus::Running);
+
+    // The current boot id is now the stored one, for the next comparison.
+    assert_eq!(
+        std::fs::read_to_string(&boot_id_path).unwrap().trim(),
+        "current-boot"
+    );
+}
+
+/// #164, still true after #174: a real reboot takes the tmux server with it,
+/// so the probe comes back empty and every sidecar is registered dormant.
+#[tokio::test]
+async fn recover_registers_dormant_when_boot_id_changed_and_tmux_gone() {
+    let fx = DaemonFixture::new();
+    let cwd = TempDir::new().unwrap();
+    let s = fx
+        .manager
+        .create(CreateSessionRequest {
+            cwd: cwd.path().to_path_buf(),
+            command: "sleep 30".into(),
+            env: HashMap::new(),
+            metadata: HashMap::new(),
+            worktree: None,
+        })
+        .await
+        .expect("create");
+
+    let boot_id_path = fx.state_dir.path().join("boot_id");
+    std::fs::write(&boot_id_path, "previous-boot").unwrap();
+    fx.tmux.tmux.kill_server().expect("kill tmux server");
+
+    let revived = revive_with_boot_id(&fx, boot_id_path, Some("current-boot"));
+    let adopted = revived.recover().await.expect("recover");
+    assert_eq!(adopted, 0, "no tmux server survived the reboot");
+
+    let snap = revived.snapshot().await;
+    assert_eq!(snap.len(), 1);
+    assert_eq!(snap[0].id, s.id);
+    assert_eq!(snap[0].status, SessionStatus::Dormant);
+}
+
+/// #164: an unchanged boot id is a plain restart — recovery probes tmux as
+/// before and adopts the still-live session `Running`.
+#[tokio::test]
+async fn recover_probes_tmux_when_boot_id_unchanged() {
+    let fx = DaemonFixture::new();
+    let cwd = TempDir::new().unwrap();
+    let s = fx
+        .manager
+        .create(CreateSessionRequest {
+            cwd: cwd.path().to_path_buf(),
+            command: "sleep 30".into(),
+            env: HashMap::new(),
+            metadata: HashMap::new(),
+            worktree: None,
+        })
+        .await
+        .expect("create");
+
+    let boot_id_path = fx.state_dir.path().join("boot_id");
+    std::fs::write(&boot_id_path, "same-boot").unwrap();
+
+    let revived = revive_with_boot_id(&fx, boot_id_path, Some("same-boot"));
+    let adopted = revived.recover().await.expect("recover");
+    assert_eq!(adopted, 1);
+    let snap = revived.snapshot().await;
+    assert_eq!(snap[0].id, s.id);
+    assert_eq!(snap[0].status, SessionStatus::Running);
+}
+
+/// #164: no stored boot id (first run ever, or an older build that never
+/// wrote one) means there is nothing to compare against — falls back to
+/// today's probe-based recovery rather than assuming a reboot.
+#[tokio::test]
+async fn recover_falls_back_to_probe_when_no_stored_boot_id() {
+    let fx = DaemonFixture::new();
+    let cwd = TempDir::new().unwrap();
+    fx.manager
+        .create(CreateSessionRequest {
+            cwd: cwd.path().to_path_buf(),
+            command: "sleep 30".into(),
+            env: HashMap::new(),
+            metadata: HashMap::new(),
+            worktree: None,
+        })
+        .await
+        .expect("create");
+
+    let boot_id_path = fx.state_dir.path().join("boot_id");
+    assert!(!boot_id_path.exists());
+
+    let revived = revive_with_boot_id(&fx, boot_id_path.clone(), Some("current-boot"));
+    let adopted = revived.recover().await.expect("recover");
+    assert_eq!(adopted, 1, "no stored boot id; falls back to probing tmux");
+    assert_eq!(
+        std::fs::read_to_string(&boot_id_path).unwrap().trim(),
+        "current-boot"
+    );
+}
+
+/// #164: an unreadable current boot id (non-Linux, restricted `/proc`) falls
+/// back to today's behaviour rather than failing startup or assuming a
+/// reboot.
+#[tokio::test]
+async fn recover_falls_back_to_probe_when_boot_id_unreadable() {
+    let fx = DaemonFixture::new();
+    let cwd = TempDir::new().unwrap();
+    fx.manager
+        .create(CreateSessionRequest {
+            cwd: cwd.path().to_path_buf(),
+            command: "sleep 30".into(),
+            env: HashMap::new(),
+            metadata: HashMap::new(),
+            worktree: None,
+        })
+        .await
+        .expect("create");
+
+    let boot_id_path = fx.state_dir.path().join("boot_id");
+    std::fs::write(&boot_id_path, "stored-boot").unwrap();
+
+    let revived = revive_with_boot_id(&fx, boot_id_path, None);
+    let adopted = revived.recover().await.expect("recover");
+    assert_eq!(adopted, 1, "boot id unreadable; falls back to probing tmux");
+}
+
+/// #162: dismissing a dormant session is the one thing that can be done to it
+/// — no tmux call to fail, and the sidecar goes with it so the next recovery
+/// does not resurrect it.
+#[tokio::test]
+async fn dormant_session_can_be_dismissed() {
+    let fx = DaemonFixture::new();
+    let cwd = TempDir::new().unwrap();
+
+    let s = fx
+        .manager
+        .create(CreateSessionRequest {
+            cwd: cwd.path().to_path_buf(),
+            command: "sleep 30".into(),
+            env: HashMap::new(),
+            metadata: HashMap::new(),
+            worktree: None,
+        })
+        .await
+        .expect("create");
+    fx.tmux.tmux.kill_server().expect("kill tmux server");
+
+    let revived = revive(&fx);
+    revived.recover().await.expect("recover");
+    revived.kill(s.id, false).await.expect("dismiss");
+
+    assert!(!revived.has(s.id).await);
+    assert!(!fx.sidecar_dir().join(format!("{}.json", s.id)).exists());
+}
+
+/// A second `SessionManager` over the same dirs and the same tmux server —
+/// what a daemon restart looks like from inside a test.
+fn revive(fx: &DaemonFixture) -> maestro_daemon::SessionManager {
+    maestro_daemon::SessionManager::new(
+        Arc::new(fx.tmux.tmux.clone()),
+        maestro_daemon::sidecar::SidecarStore::new(fx.sidecar_dir()),
+        maestro_daemon::worktree::WorktreeManager::new(None),
+        fx.fifo_dir(),
+    )
+}
+
 /// Regression for NAP-253: the very first bytes a freshly-spawned command
 /// writes must reach the replay buffer. Before the fix, `pipe-pane` was a
 /// separate tmux invocation that ran after `new-session` + an async FIFO
@@ -161,7 +538,6 @@ async fn create_captures_initial_output_in_replay_buffer() {
     let s = fx
         .manager
         .create(CreateSessionRequest {
-            view: Default::default(),
             cwd: cwd.path().to_path_buf(),
             // The shell prints the marker before doing anything else and
             // then sleeps so the session stays alive. Before NAP-253 this
@@ -170,7 +546,6 @@ async fn create_captures_initial_output_in_replay_buffer() {
             env: HashMap::new(),
             metadata: HashMap::new(),
             worktree: None,
-            auto_approve: false,
         })
         .await
         .expect("create");
@@ -210,7 +585,6 @@ async fn attach_replay_is_the_current_screen_not_the_byte_tail() {
     let s = fx
         .manager
         .create(CreateSessionRequest {
-        view: Default::default(),
             cwd: cwd.path().to_path_buf(),
             // Print a line, then switch to the alternate screen the way a
             // full-screen program does on startup. Only the second marker is
@@ -220,7 +594,6 @@ async fn attach_replay_is_the_current_screen_not_the_byte_tail() {
             env: HashMap::new(),
             metadata: HashMap::new(),
             worktree: None,
-            auto_approve: false,
         })
         .await
         .expect("create");
@@ -270,7 +643,6 @@ async fn attach_replay_carries_the_panes_mouse_modes() {
     let s = fx
         .manager
         .create(CreateSessionRequest {
-        view: Default::default(),
             cwd: cwd.path().to_path_buf(),
             // Alternate screen, then button-event tracking (?1002) with SGR
             // coordinates (?1006) — what tmux and agent TUIs actually request.
@@ -279,7 +651,6 @@ async fn attach_replay_carries_the_panes_mouse_modes() {
             env: HashMap::new(),
             metadata: HashMap::new(),
             worktree: None,
-            auto_approve: false,
         })
         .await
         .expect("create");
@@ -325,13 +696,11 @@ async fn recover_re_pipes_pane_so_output_reaches_subscribers() {
     let s = fx
         .manager
         .create(CreateSessionRequest {
-            view: Default::default(),
             cwd: cwd.path().to_path_buf(),
             command: "bash --noprofile --norc".into(),
             env: HashMap::new(),
             metadata: HashMap::new(),
             worktree: None,
-            auto_approve: false,
         })
         .await
         .expect("create");
@@ -389,13 +758,11 @@ async fn pty_broadcast_delivers_bytes_to_subscribers() {
     let s = fx
         .manager
         .create(CreateSessionRequest {
-            view: Default::default(),
             cwd: cwd.path().to_path_buf(),
             command: "bash --noprofile --norc".into(),
             env: HashMap::new(),
             metadata: HashMap::new(),
             worktree: None,
-            auto_approve: false,
         })
         .await
         .unwrap();
@@ -441,13 +808,11 @@ async fn liveness_watcher_marks_dead_sessions_and_keeps_them_until_dismissed() {
     let s = fx
         .manager
         .create(CreateSessionRequest {
-            view: Default::default(),
             cwd: cwd.path().to_path_buf(),
             command: "sleep 30".into(),
             env: HashMap::new(),
             metadata: HashMap::new(),
             worktree: None,
-            auto_approve: false,
         })
         .await
         .expect("create");
@@ -508,7 +873,6 @@ async fn watcher_refreshes_the_blocked_work_indicator() {
 
     fx.manager
         .create(CreateSessionRequest {
-            view: Default::default(),
             cwd: repo.path().to_path_buf(),
             command: "sleep 30".into(),
             env: HashMap::new(),
@@ -518,7 +882,6 @@ async fn watcher_refreshes_the_blocked_work_indicator() {
                 branch: "feat/indicator".into(),
                 create_branch: true,
             }),
-            auto_approve: false,
         })
         .await
         .expect("create");
@@ -602,7 +965,6 @@ async fn kill_removes_worktree_even_when_spec_says_keep() {
     let s = fx
         .manager
         .create(CreateSessionRequest {
-            view: Default::default(),
             cwd: repo.path().to_path_buf(),
             command: "sleep 30".into(),
             env: HashMap::new(),
@@ -612,7 +974,6 @@ async fn kill_removes_worktree_even_when_spec_says_keep() {
                 branch: "feat/keep".into(),
                 create_branch: true,
             }),
-            auto_approve: false,
         })
         .await
         .expect("create");
@@ -641,7 +1002,6 @@ async fn killing_refuses_a_worktree_with_unsaved_work_and_keeps_the_session() {
     let s = fx
         .manager
         .create(CreateSessionRequest {
-            view: Default::default(),
             cwd: repo.path().to_path_buf(),
             command: "sleep 30".into(),
             env: HashMap::new(),
@@ -651,7 +1011,6 @@ async fn killing_refuses_a_worktree_with_unsaved_work_and_keeps_the_session() {
                 branch: "feat/guarded".into(),
                 create_branch: true,
             }),
-            auto_approve: false,
         })
         .await
         .expect("create");
@@ -706,7 +1065,6 @@ async fn killing_refuses_until_the_branch_is_pushed() {
     let s = fx
         .manager
         .create(CreateSessionRequest {
-            view: Default::default(),
             cwd: repo.path().to_path_buf(),
             command: "sleep 30".into(),
             env: HashMap::new(),
@@ -716,7 +1074,6 @@ async fn killing_refuses_until_the_branch_is_pushed() {
                 branch: "feat/pushed".into(),
                 create_branch: true,
             }),
-            auto_approve: false,
         })
         .await
         .expect("create");
@@ -757,7 +1114,6 @@ async fn force_killing_a_guarded_worktree_leaves_it_on_disk() {
     let s = fx
         .manager
         .create(CreateSessionRequest {
-            view: Default::default(),
             cwd: repo.path().to_path_buf(),
             command: "sleep 30".into(),
             env: HashMap::new(),
@@ -767,7 +1123,6 @@ async fn force_killing_a_guarded_worktree_leaves_it_on_disk() {
                 branch: "feat/forced".into(),
                 create_branch: true,
             }),
-            auto_approve: false,
         })
         .await
         .expect("create");
@@ -804,7 +1159,6 @@ async fn force_on_a_clear_worktree_removes_it_as_usual() {
     let s = fx
         .manager
         .create(CreateSessionRequest {
-            view: Default::default(),
             cwd: repo.path().to_path_buf(),
             command: "sleep 30".into(),
             env: HashMap::new(),
@@ -814,7 +1168,6 @@ async fn force_on_a_clear_worktree_removes_it_as_usual() {
                 branch: "feat/clear".into(),
                 create_branch: true,
             }),
-            auto_approve: false,
         })
         .await
         .expect("create");
@@ -846,7 +1199,6 @@ async fn killing_an_ignored_only_worktree_succeeds() {
     let s = fx
         .manager
         .create(CreateSessionRequest {
-            view: Default::default(),
             cwd: repo.path().to_path_buf(),
             command: "sleep 30".into(),
             env: HashMap::new(),
@@ -856,7 +1208,6 @@ async fn killing_an_ignored_only_worktree_succeeds() {
                 branch: "feat/rusty".into(),
                 create_branch: true,
             }),
-            auto_approve: false,
         })
         .await
         .expect("create");
@@ -889,7 +1240,6 @@ async fn natural_exit_of_a_guarded_worktree_leaves_it_on_disk() {
     let s = fx
         .manager
         .create(CreateSessionRequest {
-            view: Default::default(),
             cwd: repo.path().to_path_buf(),
             command: "sleep 30".into(),
             env: HashMap::new(),
@@ -899,7 +1249,6 @@ async fn natural_exit_of_a_guarded_worktree_leaves_it_on_disk() {
                 branch: "feat/exited".into(),
                 create_branch: true,
             }),
-            auto_approve: false,
         })
         .await
         .expect("create");
@@ -952,7 +1301,6 @@ async fn natural_exit_of_a_pristine_worktree_removes_it() {
     let s = fx
         .manager
         .create(CreateSessionRequest {
-            view: Default::default(),
             cwd: repo.path().to_path_buf(),
             command: "sleep 30".into(),
             env: HashMap::new(),
@@ -962,7 +1310,6 @@ async fn natural_exit_of_a_pristine_worktree_removes_it() {
                 branch: "feat/clean".into(),
                 create_branch: true,
             }),
-            auto_approve: false,
         })
         .await
         .expect("create");
@@ -992,6 +1339,65 @@ async fn natural_exit_of_a_pristine_worktree_removes_it() {
     );
 }
 
+/// #172: `mark_session_dead` clears the worktree off the in-memory record
+/// when a pristine tree settles, but the local `session` clone it writes to
+/// the sidecar and broadcasts must be cleared the same way — otherwise the
+/// sidecar keeps naming a tree the daemon just removed, and a recovery from
+/// that sidecar advertises a branch and path that no longer exist.
+#[tokio::test]
+async fn natural_exit_of_a_pristine_worktree_clears_it_from_the_sidecar() {
+    let fx = DaemonFixture::new();
+    let repo = TempDir::new().unwrap();
+    init_repo(repo.path());
+    let wt_path = repo.path().join("worktrees").join("feat").join("sidecar");
+
+    let s = fx
+        .manager
+        .create(CreateSessionRequest {
+            cwd: repo.path().to_path_buf(),
+            command: "sleep 30".into(),
+            env: HashMap::new(),
+            metadata: HashMap::new(),
+            worktree: Some(WorktreeSpec {
+                base_repo: repo.path().to_path_buf(),
+                branch: "feat/sidecar".into(),
+                create_branch: true,
+            }),
+        })
+        .await
+        .expect("create");
+
+    // Push everything so the branch has no unpushed commits: fully pristine.
+    let origin = TempDir::new().unwrap();
+    init_bare_repo(origin.path());
+    push_all_to_origin(repo.path(), origin.path());
+
+    fx.tmux.tmux.kill_session(s.id).expect("kill tmux directly");
+    fx.manager.start_liveness_watcher(Duration::from_millis(50));
+    wait_for_async(Duration::from_secs(3), || async {
+        fx.manager.status(s.id).await == Some(SessionStatus::Dead)
+    })
+    .await;
+    wait_for_async(Duration::from_secs(3), || async {
+        fx.manager.is_settled(s.id).await == Some(true)
+    })
+    .await;
+
+    assert!(
+        !wt_path.exists(),
+        "a pristine worktree leaves nothing behind"
+    );
+
+    let sidecar = SidecarStore::new(fx.sidecar_dir())
+        .read(s.id)
+        .expect("sidecar read")
+        .expect("sidecar exists");
+    assert!(
+        sidecar.worktree.is_none(),
+        "the sidecar must not keep naming a worktree the daemon already removed"
+    );
+}
+
 fn run_git_in(dir: &std::path::Path, args: &[&str]) {
     let out = Command::new("git")
         .arg("-C")
@@ -1014,13 +1420,11 @@ async fn liveness_watcher_leaves_running_sessions_alone() {
     let s = fx
         .manager
         .create(CreateSessionRequest {
-            view: Default::default(),
             cwd: cwd.path().to_path_buf(),
             command: "sleep 30".into(),
             env: HashMap::new(),
             metadata: HashMap::new(),
             worktree: None,
-            auto_approve: false,
         })
         .await
         .expect("create");
@@ -1050,7 +1454,6 @@ async fn worktree_base_repo_records_the_main_checkout_not_the_request() {
     let first = fx
         .manager
         .create(CreateSessionRequest {
-            view: Default::default(),
             cwd: repo.path().to_path_buf(),
             command: "sleep 30".into(),
             env: HashMap::new(),
@@ -1060,7 +1463,6 @@ async fn worktree_base_repo_records_the_main_checkout_not_the_request() {
                 branch: "feat/one".into(),
                 create_branch: true,
             }),
-            auto_approve: false,
         })
         .await
         .expect("create first");
@@ -1069,7 +1471,6 @@ async fn worktree_base_repo_records_the_main_checkout_not_the_request() {
     let second = fx
         .manager
         .create(CreateSessionRequest {
-            view: Default::default(),
             cwd: inner_worktree.clone(),
             command: "sleep 30".into(),
             env: HashMap::new(),
@@ -1079,7 +1480,6 @@ async fn worktree_base_repo_records_the_main_checkout_not_the_request() {
                 branch: "feat/two".into(),
                 create_branch: true,
             }),
-            auto_approve: false,
         })
         .await
         .expect("create second");
@@ -1109,13 +1509,11 @@ async fn spawned_sessions_export_maestro_session_id_and_url() {
     let s = fx
         .manager
         .create(CreateSessionRequest {
-            view: Default::default(),
             cwd: cwd.path().to_path_buf(),
             command: "sleep 30".into(),
             env: HashMap::new(),
             metadata: HashMap::new(),
             worktree: None,
-            auto_approve: false,
         })
         .await
         .expect("create");
@@ -1149,13 +1547,11 @@ async fn a_freshly_created_session_has_never_been_focused() {
     let s = fx
         .manager
         .create(CreateSessionRequest {
-            view: Default::default(),
             cwd: cwd.path().to_path_buf(),
             command: "sleep 30".into(),
             env: HashMap::new(),
             metadata: HashMap::new(),
             worktree: None,
-            auto_approve: false,
         })
         .await
         .expect("create");
@@ -1176,13 +1572,11 @@ async fn set_focused_true_stamps_last_focused_at() {
     let s = fx
         .manager
         .create(CreateSessionRequest {
-            view: Default::default(),
             cwd: cwd.path().to_path_buf(),
             command: "sleep 30".into(),
             env: HashMap::new(),
             metadata: HashMap::new(),
             worktree: None,
-            auto_approve: false,
         })
         .await
         .expect("create");
@@ -1226,13 +1620,11 @@ async fn attaching_stamps_last_focused_at() {
     let s = fx
         .manager
         .create(CreateSessionRequest {
-            view: Default::default(),
             cwd: cwd.path().to_path_buf(),
             command: "sleep 30".into(),
             env: HashMap::new(),
             metadata: HashMap::new(),
             worktree: None,
-            auto_approve: false,
         })
         .await
         .expect("create");

crates/maestro-daemon/tests/sidecar.rs

@@ -6,8 +6,8 @@ use std::collections::HashMap;
 use std::path::PathBuf;
 
 use chrono::{DateTime, Utc};
-use maestro_daemon::sidecar::{PersistedEvent, SidecarStore};
-use maestro_protocol::{Session, SessionStatus, SessionView, TranscriptRow, TranscriptRowKind};
+use maestro_daemon::sidecar::SidecarStore;
+use maestro_protocol::{Session, SessionStatus};
 use serde_json::Value;
 use tempfile::TempDir;
 use uuid::Uuid;
@@ -32,10 +32,7 @@ fn sample(id: Uuid) -> Session {
         current_cwd: Some(PathBuf::from("/tmp/work/crates")),
         blocked_work: None,
         last_focused_at: None,
-        acp_session_id: None,
-        view: SessionView::Terminal,
-        auto_approve: false,
-        queued_prompts: Vec::new(),
+        agent_session_id: Some("conv-abc123".into()),
     }
 }
 
@@ -70,30 +67,15 @@ fn delete_removes_file_and_is_idempotent() {
     let s = sample(id);
 
     store.write(&s).unwrap();
-    store.mark_for_recovery(id).unwrap();
     assert!(store.path_for(id).exists());
-    assert!(store.recovery_path_for(id).exists());
 
     store.delete(id).unwrap();
     assert!(!store.path_for(id).exists());
-    assert!(!store.recovery_path_for(id).exists());
 
     // second delete is a no-op
     store.delete(id).unwrap();
 }
 
-#[test]
-fn recovery_marker_is_consumed_once() {
-    let dir = TempDir::new().unwrap();
-    let store = SidecarStore::new(dir.path());
-    let id = Uuid::new_v4();
-
-    assert!(!store.take_recovery_marker(id).unwrap());
-    store.mark_for_recovery(id).unwrap();
-    assert!(store.take_recovery_marker(id).unwrap());
-    assert!(!store.take_recovery_marker(id).unwrap());
-}
-
 #[test]
 fn load_all_recovers_every_sidecar_and_skips_garbage() {
     let dir = TempDir::new().unwrap();
@@ -122,37 +104,6 @@ fn load_all_returns_empty_when_directory_missing() {
     assert!(store.load_all().unwrap().is_empty());
 }
 
-#[test]
-fn sidecar_missing_view_key_reads_as_terminal() {
-    // A pre-#133 sidecar on disk has no `view` field at all.
-    let dir = TempDir::new().unwrap();
-    let store = SidecarStore::new(dir.path());
-    let id = Uuid::new_v4();
-
-    let mut value = serde_json::to_value(sample(id)).unwrap();
-    value.as_object_mut().unwrap().remove("view");
-    std::fs::write(store.path_for(id), serde_json::to_vec(&value).unwrap()).unwrap();
-
-    let loaded = store.read(id).expect("read").expect("present");
-    assert_eq!(loaded.view, SessionView::Terminal);
-}
-
-#[test]
-fn sidecar_structured_view_round_trips() {
-    let dir = TempDir::new().unwrap();
-    let store = SidecarStore::new(dir.path());
-    let id = Uuid::new_v4();
-    let mut s = sample(id);
-    s.view = SessionView::Structured;
-
-    store.write(&s).expect("write");
-    let loaded = store.read(id).expect("read");
-    assert_eq!(
-        loaded.as_ref().map(|s| s.view),
-        Some(SessionView::Structured)
-    );
-}
-
 #[test]
 fn write_creates_parent_directory() {
     let dir = TempDir::new().unwrap();
@@ -163,237 +114,3 @@ fn write_creates_parent_directory() {
     assert!(nested.exists());
     assert!(store.path_for(s.id).exists());
 }
-
-// ---- per-session event log (#135) ----
-
-use maestro_acp::schema::{ContentBlock, SessionNotification, SessionUpdate, TextContent};
-use maestro_daemon::sidecar::EventCursor;
-
-fn note(text: &str) -> SessionNotification {
-    SessionNotification::new(
-        "acp-1",
-        SessionUpdate::AgentMessageChunk(maestro_acp::schema::ContentChunk::new(
-            ContentBlock::Text(TextContent::new(text)),
-        )),
-    )
-}
-
-fn text_of(n: &SessionNotification) -> &str {
-    match &n.update {
-        SessionUpdate::AgentMessageChunk(chunk) => match &chunk.content {
-            ContentBlock::Text(t) => &t.text,
-            other => panic!("unexpected content {other:?}"),
-        },
-        other => panic!("unexpected update {other:?}"),
-    }
-}
-
-fn event_text(event: &maestro_daemon::sidecar::LoggedEvent) -> &str {
-    let maestro_daemon::sidecar::PersistedEvent::Notification(notification) = &event.event else {
-        panic!("expected ACP notification")
-    };
-    text_of(notification)
-}
-
-#[test]
-fn append_assigns_line_position_as_seq_and_reads_back() {
-    let dir = TempDir::new().unwrap();
-    let store = SidecarStore::new(dir.path());
-    let id = Uuid::new_v4();
-
-    let mut log = store.open_events(id).expect("open");
-    assert_eq!(log.last_seq(), 0);
-    assert_eq!(log.append(note("a")).unwrap(), 1);
-    assert_eq!(log.append(note("b")).unwrap(), 2);
-    assert_eq!(log.append(note("c")).unwrap(), 3);
-    assert_eq!(log.last_seq(), 3);
-
-    let path = store.events_path_for(id);
-    assert!(path.ends_with(format!("{id}.events.jsonl")), "{path:?}");
-    let raw = std::fs::read_to_string(&path).unwrap();
-    assert_eq!(raw.lines().count(), 3, "one object per line:\n{raw}");
-    for line in raw.lines() {
-        let v: Value = serde_json::from_str(line).expect("each line is one JSON object");
-        assert_eq!(v["sessionId"], "acp-1");
-    }
-
-    let all = store.read_events(id, EventCursor::Since(0), 100).unwrap();
-    assert_eq!(all.iter().map(|e| e.seq).collect::<Vec<_>>(), vec![1, 2, 3]);
-    assert_eq!(
-        all.iter().map(event_text).collect::<Vec<_>>(),
-        vec!["a", "b", "c"]
-    );
-}
-
-#[test]
-fn since_reads_forward_and_before_reads_backward_with_limit() {
-    let dir = TempDir::new().unwrap();
-    let store = SidecarStore::new(dir.path());
-    let id = Uuid::new_v4();
-    let mut log = store.open_events(id).unwrap();
-    for i in 1..=6 {
-        log.append(note(&format!("n{i}"))).unwrap();
-    }
-
-    // `since` is exclusive: what a client that already holds seq 2 needs.
-    let fwd = store.read_events(id, EventCursor::Since(2), 3).unwrap();
-    assert_eq!(fwd.iter().map(|e| e.seq).collect::<Vec<_>>(), vec![3, 4, 5]);
-    // Past the end: nothing, not an error.
-    assert!(store
-        .read_events(id, EventCursor::Since(6), 3)
-        .unwrap()
-        .is_empty());
-
-    // `before` is exclusive and pages backward: the `limit` events closest
-    // to the cursor, still in ascending seq order.
-    let back = store
-        .read_events(id, EventCursor::Before(Some(5)), 2)
-        .unwrap();
-    assert_eq!(back.iter().map(|e| e.seq).collect::<Vec<_>>(), vec![3, 4]);
-    // No cursor: the tail of the log, for a first paint.
-    let tail = store.read_events(id, EventCursor::Before(None), 2).unwrap();
-    assert_eq!(tail.iter().map(|e| e.seq).collect::<Vec<_>>(), vec![5, 6]);
-    // Paging past the start runs out cleanly.
-    let start = store
-        .read_events(id, EventCursor::Before(Some(2)), 10)
-        .unwrap();
-    assert_eq!(start.iter().map(|e| e.seq).collect::<Vec<_>>(), vec![1]);
-    assert!(store
-        .read_events(id, EventCursor::Before(Some(1)), 10)
-        .unwrap()
-        .is_empty());
-}
-
-#[test]
-fn missing_log_reads_as_empty() {
-    let dir = TempDir::new().unwrap();
-    let store = SidecarStore::new(dir.path());
-    let id = Uuid::new_v4();
-    assert!(store
-        .read_events(id, EventCursor::Since(0), 10)
-        .unwrap()
-        .is_empty());
-    assert!(store
-        .read_events(id, EventCursor::Before(None), 10)
-        .unwrap()
-        .is_empty());
-}
-
-#[test]
-fn malformed_lines_are_skipped_but_keep_their_seq() {
-    let dir = TempDir::new().unwrap();
-    let store = SidecarStore::new(dir.path());
-    let id = Uuid::new_v4();
-    let mut log = store.open_events(id).unwrap();
-    log.append(note("first")).unwrap();
-    drop(log);
-
-    // Garbage in the middle and a line that is JSON but not a notification.
-    let path = store.events_path_for(id);
-    let mut raw = std::fs::read_to_string(&path).unwrap();
-    raw.push_str("{not json\n");
-    raw.push_str("{\"unrelated\": true}\n");
-    std::fs::write(&path, raw).unwrap();
-    let mut log = store.open_events(id).unwrap();
-    assert_eq!(log.last_seq(), 3);
-    assert_eq!(log.append(note("fourth")).unwrap(), 4);
-
-    let all = store.read_events(id, EventCursor::Since(0), 10).unwrap();
-    assert_eq!(all.iter().map(|e| e.seq).collect::<Vec<_>>(), vec![1, 4]);
-    assert_eq!(event_text(&all[1]), "fourth");
-}
-
-#[test]
-fn truncated_last_line_still_opens_and_the_next_append_starts_a_fresh_line() {
-    // A hard kill mid-write leaves a partial line with no newline.
-    let dir = TempDir::new().unwrap();
-    let store = SidecarStore::new(dir.path());
-    let id = Uuid::new_v4();
-    let mut log = store.open_events(id).unwrap();
-    log.append(note("whole")).unwrap();
-    drop(log);
-
-    let path = store.events_path_for(id);
-    let mut raw = std::fs::read(&path).unwrap();
-    raw.extend_from_slice(br#"{"sessionId":"acp-1","update":{"sessionUpd"#);
-    std::fs::write(&path, &raw).unwrap();
-
-    // Reads: the partial line is skipped, nothing else is lost.
-    let all = store.read_events(id, EventCursor::Since(0), 10).unwrap();
-    assert_eq!(all.iter().map(|e| e.seq).collect::<Vec<_>>(), vec![1]);
-
-    // Reopening terminates the partial line so the next append does not
-    // glue onto it; the partial keeps a seq of its own.
-    let mut log = store.open_events(id).unwrap();
-    assert_eq!(log.last_seq(), 2);
-    assert_eq!(log.append(note("after")).unwrap(), 3);
-    let all = store.read_events(id, EventCursor::Since(0), 10).unwrap();
-    assert_eq!(all.iter().map(|e| e.seq).collect::<Vec<_>>(), vec![1, 3]);
-    assert_eq!(event_text(&all[1]), "after");
-    let raw = std::fs::read_to_string(&path).unwrap();
-    assert_eq!(raw.lines().count(), 3, "{raw}");
-}
-
-#[test]
-fn delete_removes_the_event_log_and_load_all_ignores_it() {
-    let dir = TempDir::new().unwrap();
-    let store = SidecarStore::new(dir.path());
-    let id = Uuid::new_v4();
-    store.write(&sample(id)).unwrap();
-    let mut log = store.open_events(id).unwrap();
-    log.append(note("x")).unwrap();
-    drop(log);
-    let legacy_approvals = dir.path().join(format!("{id}.approvals.jsonl"));
-    std::fs::write(&legacy_approvals, b"obsolete").unwrap();
-    assert!(store.events_path_for(id).exists());
-
-    let loaded = store.load_all().unwrap();
-    assert_eq!(loaded.len(), 1, "the .jsonl must not be read as a sidecar");
-
-    store.delete(id).unwrap();
-    assert!(!store.path_for(id).exists());
-    assert!(!store.events_path_for(id).exists());
-    assert!(!legacy_approvals.exists());
-    // Idempotent with the log already gone.
-    store.delete(id).unwrap();
-}
-
-#[test]
-fn approval_rows_share_event_cursors_with_legacy_acp_lines() {
-    let dir = TempDir::new().unwrap();
-    let store = SidecarStore::new(dir.path());
-    let id = Uuid::new_v4();
-    let legacy = serde_json::to_vec(&note("before")).unwrap();
-    std::fs::create_dir_all(dir.path()).unwrap();
-    std::fs::write(store.events_path_for(id), [legacy, b"\n".to_vec()].concat()).unwrap();
-
-    let mut log = store.open_events(id).unwrap();
-    assert_eq!(
-        log.append(PersistedEvent::Approval {
-            row: TranscriptRow {
-                id: "approval:secret".into(),
-                kind: TranscriptRowKind::Approval,
-                data: serde_json::json!({"tool": "bash"}),
-            },
-        })
-        .unwrap(),
-        2
-    );
-    assert_eq!(log.append(note("after")).unwrap(), 3);
-
-    let all = store.read_events(id, EventCursor::Since(0), 10).unwrap();
-    assert_eq!(
-        all.iter().map(|event| event.seq).collect::<Vec<_>>(),
-        [1, 2, 3]
-    );
-    assert!(matches!(all[1].event, PersistedEvent::Approval { .. }));
-    assert_eq!(event_text(&all[0]), "before");
-    assert_eq!(event_text(&all[2]), "after");
-
-    let since = store.read_events(id, EventCursor::Since(1), 1).unwrap();
-    assert_eq!(since[0].seq, 2);
-    let before = store
-        .read_events(id, EventCursor::Before(Some(3)), 1)
-        .unwrap();
-    assert_eq!(before[0].seq, 2);
-}

crates/maestro-daemon/tests/web_ui.rs

@@ -59,7 +59,7 @@ async fn root_serves_the_spa_shell() {
             .map(|v| v.starts_with("text/html")),
         Some(true)
     );
-    assert!(resp.text().await.unwrap().contains(r#"id="root""#));
+    assert!(resp.text().await.unwrap().contains(r#"id="app""#));
 }
 
 #[tokio::test]
@@ -69,7 +69,7 @@ async fn client_side_route_falls_back_to_the_shell() {
         .await
         .unwrap();
     assert_eq!(resp.status(), 200);
-    assert!(resp.text().await.unwrap().contains(r#"id="root""#));
+    assert!(resp.text().await.unwrap().contains(r#"id="app""#));
 }
 
 /// An unmatched API path must 404 rather than fall through to the SPA shell:

crates/maestro-daemon/tests/worktree.rs

@@ -405,17 +405,13 @@ fn run_git(dir: &std::path::Path, args: &[&str]) {
     );
 }
 
-/// `git worktree add -b` alone fails outright when the branch already exists,
-/// even with the target directory free — a random handle commonly collides
-/// with one an earlier, already-removed worktree left behind. `add_new`
-/// sidesteps it on the branch name itself instead of erroring (#77).
 #[test]
-fn add_new_suffixes_branch_name_on_branch_collision() {
+fn add_fails_when_branch_already_exists() {
     let repo_dir = TempDir::new().unwrap();
     let repo = repo_dir.path().to_path_buf();
     init_repo(&repo);
 
-    // pre-create the branch, unused by any worktree.
+    // pre-create the branch
     let status = Command::new("git")
         .arg("-C")
         .arg(&repo)
@@ -427,17 +423,9 @@ fn add_new_suffixes_branch_name_on_branch_collision() {
     let wt_root = TempDir::new().unwrap();
     let mgr = WorktreeManager::new(Some(wt_root.path().to_path_buf()));
 
-    let path = mgr
-        .add_new(&repo, "feat/dup")
-        .expect("sidesteps the branch collision");
-    assert!(path.ends_with("feat/dup-2"), "{}", path.display());
-    assert!(path.exists());
-
-    // The pre-existing branch is untouched; the new worktree checked out the
-    // suffixed one instead of erroring or adopting `feat/dup`.
-    let branches = worktree_branches(&repo);
-    assert!(branches.contains(&"feat/dup-2".to_string()), "{branches:?}");
-    assert!(!branches.contains(&"feat/dup".to_string()), "{branches:?}");
+    let err = mgr.add_new(&repo, "feat/dup").unwrap_err();
+    let msg = format!("{err}");
+    assert!(msg.contains("git exited"), "{msg}");
 }
 
 /// The project picker lists linked worktrees as pickable rows, so `base_repo`

crates/maestro-e2e/Cargo.toml

@@ -13,7 +13,6 @@ path = "src/lib.rs"
 [dependencies]
 chrono.workspace = true
 futures-util.workspace = true
-libc.workspace = true
 maestro-protocol = { workspace = true, features = ["client"] }
 maestro-testing.workspace = true
 serde.workspace = true

crates/maestro-e2e/src/daemon.rs

@@ -87,14 +87,6 @@ impl Daemon {
         }
     }
 
-    /// Send the daemon the same SIGTERM systemd uses, without waiting for its
-    /// graceful HTTP shutdown to finish.
-    pub fn send_sigterm(&self) {
-        let child = self.child.as_ref().expect("daemon is running");
-        let result = unsafe { libc::kill(child.id() as libc::pid_t, libc::SIGTERM) };
-        assert_eq!(result, 0, "send SIGTERM to daemon");
-    }
-
     /// Re-spawn the daemon on the same port + state. The previous tmux
     /// server (under `TMUX_TMPDIR`) is left running so `recover()` can adopt
     /// its sessions.

crates/maestro-e2e/tests/e2e.rs

@@ -15,7 +15,7 @@ use std::time::{Duration, Instant};
 use futures_util::{SinkExt, StreamExt};
 use maestro_e2e::util::wait_for_async;
 use maestro_e2e::{Daemon, TestClient};
-use maestro_protocol::{CreateSessionRequest, SessionStatus, SessionView, WorktreeSpec};
+use maestro_protocol::{CreateSessionRequest, WorktreeSpec};
 use tempfile::TempDir;
 use tokio_tungstenite::tungstenite::Message as WsMessage;
 
@@ -27,71 +27,14 @@ async fn bring_up() -> (Daemon, TestClient) {
 
 fn create_req(cwd: &std::path::Path, command: &str) -> CreateSessionRequest {
     CreateSessionRequest {
-        view: Default::default(),
         cwd: cwd.to_path_buf(),
         command: command.into(),
         env: HashMap::new(),
         metadata: HashMap::new(),
         worktree: None,
-        auto_approve: false,
     }
 }
 
-struct FakeAcp {
-    _dir: TempDir,
-    env: HashMap<String, String>,
-}
-
-fn fake_acp(log: &std::path::Path) -> FakeAcp {
-    let dir = tempfile::tempdir().expect("fake adapter dir");
-    let adapter = dir.path().join("claude-code-acp");
-    std::fs::copy(
-        concat!(
-            env!("CARGO_MANIFEST_DIR"),
-            "/../maestro-acp/tests/fake_acp_agent.py"
-        ),
-        &adapter,
-    )
-    .expect("copy fake adapter");
-    let mut permissions = std::fs::metadata(&adapter)
-        .expect("adapter metadata")
-        .permissions();
-    #[cfg(unix)]
-    {
-        use std::os::unix::fs::PermissionsExt;
-        permissions.set_mode(0o755);
-    }
-    std::fs::set_permissions(&adapter, permissions).expect("make fake adapter executable");
-    let env = HashMap::from([
-        (
-            "PATH".into(),
-            format!(
-                "{}:{}",
-                dir.path().display(),
-                std::env::var("PATH").unwrap_or_default()
-            ),
-        ),
-        ("FAKE_ACP_LOG".into(), log.to_string_lossy().into_owned()),
-    ]);
-    FakeAcp { _dir: dir, env }
-}
-
-fn fake_acp_pid(log: &std::path::Path) -> Option<u32> {
-    std::fs::read_to_string(log).ok()?.lines().find_map(|line| {
-        line.strip_prefix("start pid=")?
-            .split(' ')
-            .next()?
-            .parse()
-            .ok()
-    })
-}
-
-fn pid_alive(pid: u32) -> bool {
-    std::fs::read_to_string(format!("/proc/{pid}/stat"))
-        .map(|stat| !stat.contains(") Z "))
-        .unwrap_or(false)
-}
-
 /// A worktree spec built through its wire shape. The daemon and clients ship
 /// together (#87 dropped `cleanup_on_kill` from the struct), so the JSON
 /// object carries only the fields the lifecycle actually honours.
@@ -106,13 +49,11 @@ fn worktree_spec(base_repo: &std::path::Path, branch: &str, create_branch: bool)
 /// Spawn request carrying a worktree spec against `base`.
 fn worktree_req(base: &std::path::Path, branch: &str, create_branch: bool) -> CreateSessionRequest {
     CreateSessionRequest {
-        view: Default::default(),
         cwd: base.to_path_buf(),
         command: "sleep 30".into(),
         env: HashMap::new(),
         metadata: HashMap::new(),
         worktree: Some(worktree_spec(base, branch, create_branch)),
-        auto_approve: false,
     }
 }
 
@@ -202,13 +143,11 @@ async fn kill_removes_clean_worktree() {
     init_repo(base.path());
 
     let req = CreateSessionRequest {
-        view: Default::default(),
         cwd: base.path().to_path_buf(),
         command: "sleep 30".into(),
         env: HashMap::new(),
         metadata: HashMap::new(),
         worktree: Some(worktree_spec(base.path(), "feature/e2e", true)),
-        auto_approve: false,
     };
 
     let s = client.spawn_session(&req).await.expect("spawn worktree");
@@ -257,13 +196,11 @@ async fn kill_refuses_worktree_with_uncommitted_changes() {
         .join("unsaved");
 
     let req = CreateSessionRequest {
-        view: Default::default(),
         cwd: base.path().to_path_buf(),
         command: "sleep 30".into(),
         env: HashMap::new(),
         metadata: HashMap::new(),
         worktree: Some(worktree_spec(base.path(), "feature/unsaved", true)),
-        auto_approve: false,
     };
 
     let s = client.spawn_session(&req).await.expect("spawn worktree");
@@ -317,13 +254,11 @@ async fn spawn_on_existing_branch_checks_it_out() {
     run_git(&["branch", "feature/existing"], base.path());
 
     let req = CreateSessionRequest {
-        view: Default::default(),
         cwd: base.path().to_path_buf(),
         command: "sleep 30".into(),
         env: HashMap::new(),
         metadata: HashMap::new(),
         worktree: Some(worktree_spec(base.path(), "feature/existing", false)),
-        auto_approve: false,
     };
 
     let s = client
@@ -388,11 +323,10 @@ async fn spawn_new_branch_creates_worktree_and_runs_in_it() {
     client.kill_session(s.id).await.expect("kill");
 }
 
-/// #66/#77: a second spawn onto the same branch used to be rejected outright;
-/// since the branch-collision suffixing landed, it succeeds instead — the
-/// second worktree lands on `<branch>-2` and the first stays untouched.
+/// #66: a second spawn onto a branch that already has a worktree is rejected
+/// with a structured worktree error; the first worktree stays intact.
 #[tokio::test(flavor = "multi_thread")]
-async fn second_spawn_on_same_branch_gets_suffixed() {
+async fn second_spawn_on_same_branch_is_rejected() {
     let (_daemon, client) = bring_up().await;
 
     let base = TempDir::new().unwrap();
@@ -402,33 +336,28 @@ async fn second_spawn_on_same_branch_gets_suffixed() {
         .spawn_session(&worktree_req(base.path(), "feature/dup", true))
         .await
         .expect("first spawn");
-    let second = client
+    let dup = client
         .spawn_session(&worktree_req(base.path(), "feature/dup", true))
-        .await
-        .expect("second spawn suffixes instead of rejecting");
+        .await;
+    match dup {
+        Err(maestro_e2e::ClientError::Api(maestro_protocol::ClientError::Api { info, .. })) => {
+            assert_eq!(
+                info.code, "worktree_failed",
+                "expected worktree error: {info:?}"
+            );
+        }
+        other => panic!("expected rejection for duplicate branch, got {other:?}"),
+    }
 
-    let suffixed = base.path().join("worktrees").join("feature").join("dup-2");
-    assert_eq!(
-        second.cwd, suffixed,
-        "second worktree must land on the suffixed path"
-    );
-    assert!(suffixed.is_dir());
-
-    // Both registrations exist: the original branch, untouched, and the
-    // suffixed one the second spawn created.
-    let registrations = git_worktree_list(base.path());
-    assert!(
-        registrations
-            .iter()
-            .any(|l| l.as_str() == "branch refs/heads/feature/dup"),
-        "original branch must stay registered: {registrations:?}"
-    );
-    assert!(
-        registrations
-            .iter()
-            .any(|l| l.as_str() == "branch refs/heads/feature/dup-2"),
-        "suffixed branch must be registered too: {registrations:?}"
-    );
+    // Exactly one registration, one directory, still usable.
+    // Count branch records only: the worktree path now contains the branch
+    // name too (`worktrees/feature/dup`), so a substring match over every line
+    // would count the same tree twice.
+    let holders = git_worktree_list(base.path())
+        .iter()
+        .filter(|w| w.as_str() == "branch refs/heads/feature/dup")
+        .count();
+    assert_eq!(holders, 1, "duplicate spawn must not register another tree");
     assert!(
         base.path()
             .join("worktrees")
@@ -439,8 +368,7 @@ async fn second_spawn_on_same_branch_gets_suffixed() {
     );
 
     let _origin = throwaway_origin(base.path());
-    client.kill_session(first.id).await.expect("kill first");
-    client.kill_session(second.id).await.expect("kill second");
+    client.kill_session(first.id).await.expect("kill");
 }
 
 /// #66/#56: when the client picks a *linked worktree* as base_repo, placement
@@ -569,57 +497,6 @@ async fn occupied_path_gets_suffixed_directory_and_both_worktrees_work() {
     );
 }
 
-/// A random handle can reuse the name of a branch left behind by an earlier,
-/// already-removed worktree — `git worktree add -b` refuses outright in that
-/// case, even though the directory is free. The daemon suffixes the branch
-/// itself (not just the directory) and both land on `-2`.
-#[tokio::test(flavor = "multi_thread")]
-async fn colliding_branch_name_gets_suffixed_too() {
-    let (_daemon, client) = bring_up().await;
-
-    let base = TempDir::new().unwrap();
-    init_repo(base.path());
-
-    // No worktree directory in the way, but the branch already exists.
-    run_git(&["branch", "handle"], base.path());
-
-    let s = client
-        .spawn_session(&worktree_req(base.path(), "handle", true))
-        .await
-        .expect("spawn onto a taken branch name");
-
-    let suffixed = base.path().join("worktrees").join("handle-2");
-    assert_eq!(
-        s.cwd, suffixed,
-        "the directory must follow the suffixed branch name"
-    );
-    assert!(suffixed.is_dir());
-
-    let registrations = git_worktree_list(base.path());
-    assert!(
-        registrations.iter().any(|l| l.contains("handle-2")),
-        "the -2 branch's worktree must be registered: {registrations:?}"
-    );
-
-    let branches = String::from_utf8(
-        std::process::Command::new("git")
-            .arg("-C")
-            .arg(base.path())
-            .args(["branch", "--list"])
-            .output()
-            .unwrap()
-            .stdout,
-    )
-    .unwrap();
-    assert!(
-        branches.contains("handle-2"),
-        "the branch itself must be named handle-2: {branches}"
-    );
-
-    let _origin = throwaway_origin(base.path());
-    client.kill_session(s.id).await.expect("kill");
-}
-
 /// #77/#88: the target path holds a plain directory the daemon never made and
 /// git has never heard of. The daemon neither adopts it nor errors — it builds
 /// beside it and leaves every byte of it alone.
@@ -777,7 +654,7 @@ async fn unpushed_commits_block_kill_and_force_keeps_the_tree() {
         other => panic!("expected a kill_guarded refusal, got {other:?}"),
     }
 
-    // Force overrides the refusal: session gone, tree removed.
+    // Force overrides the refusal and nothing else: session gone, tree kept.
     client.kill_session_forced(s.id).await.expect("forced kill");
 
     assert!(
@@ -789,12 +666,12 @@ async fn unpushed_commits_block_kill_and_force_keeps_the_tree() {
             .any(|x| x.id == s.id),
         "the forced kill ends the session"
     );
-    assert!(!wt.is_dir(), "a forced kill removes the worktree");
+    assert!(wt.is_dir(), "a guarded worktree must stay on disk");
     assert!(
-        !git_worktree_list(base.path())
+        git_worktree_list(base.path())
             .iter()
             .any(|l| l.contains("feature/local")),
-        "the removed tree is unregistered from git"
+        "the kept tree stays registered in git"
     );
 }
 
@@ -826,13 +703,11 @@ async fn natural_exit_settles_dirty_and_pristine_worktrees_differently() {
 
     let _dirty = client
         .spawn_session(&CreateSessionRequest {
-            view: Default::default(),
             cwd: dirty_repo.path().to_path_buf(),
             command: "sh -c 'echo unsaved > scratch.txt'".into(),
             env: HashMap::new(),
             metadata: HashMap::new(),
             worktree: Some(worktree_spec(dirty_repo.path(), "feature/messy", true)),
-            auto_approve: false,
         })
         .await
         .expect("spawn dirty");
@@ -876,13 +751,11 @@ async fn natural_exit_settles_dirty_and_pristine_worktrees_differently() {
 
 fn create_req_cmd(cwd: &std::path::Path, command: &str, branch: &str) -> CreateSessionRequest {
     CreateSessionRequest {
-        view: Default::default(),
         cwd: cwd.to_path_buf(),
         command: command.into(),
         env: HashMap::new(),
         metadata: HashMap::new(),
         worktree: Some(worktree_spec(cwd, branch, true)),
-        auto_approve: false,
     }
 }
 
@@ -1061,67 +934,6 @@ async fn daemon_restart_recovers_session() {
     client.kill_session(s.id).await.expect("kill");
 }
 
-#[tokio::test(flavor = "multi_thread")]
-async fn sigterm_stops_structured_child_before_events_ws_drains() {
-    let (mut daemon, client) = bring_up().await;
-    let cwd = TempDir::new().unwrap();
-    let log = cwd.path().join("fake-acp.log");
-    let fake = fake_acp(&log);
-    let session = client
-        .spawn_session(&CreateSessionRequest {
-            view: SessionView::Structured,
-            cwd: cwd.path().to_path_buf(),
-            command: "claude".into(),
-            env: fake.env.clone(),
-            metadata: HashMap::new(),
-            worktree: None,
-            auto_approve: false,
-        })
-        .await
-        .expect("spawn structured session");
-    let ws_url = daemon.client().events_url().expect("events URL");
-    let (_events_ws, _) = tokio_tungstenite::connect_async(ws_url)
-        .await
-        .expect("events WS handshake");
-    wait_for_async("fake ACP starts", Duration::from_secs(5), || {
-        let log = log.clone();
-        async move { fake_acp_pid(&log).is_some() }
-    })
-    .await;
-    let pid = fake_acp_pid(&log).expect("fake ACP pid");
-
-    daemon.send_sigterm();
-
-    wait_for_async(
-        "fake ACP exits after SIGTERM",
-        Duration::from_secs(5),
-        || async { !pid_alive(pid) },
-    )
-    .await;
-    let sidecar_path = daemon
-        .state_dir()
-        .join("sessions")
-        .join(format!("{}.json", session.id));
-    wait_for_async(
-        "dead structured session sidecar",
-        Duration::from_secs(5),
-        || {
-            let sidecar_path = sidecar_path.clone();
-            async move {
-                std::fs::read(&sidecar_path)
-                    .ok()
-                    .and_then(|json| {
-                        serde_json::from_slice::<maestro_protocol::Session>(&json).ok()
-                    })
-                    .is_some_and(|saved| saved.status == SessionStatus::Dead)
-            }
-        },
-    )
-    .await;
-
-    daemon.stop();
-}
-
 #[tokio::test(flavor = "multi_thread")]
 async fn concurrent_spawns_each_get_unique_ids() {
     let (_daemon, client) = bring_up().await;

crates/maestro-hooks/src/lib.rs

@@ -1,4 +1,4 @@
-//! Agent activity hook (#106).
+//! Claude Code activity hook (#106).
 //!
 //! Two halves, both shared by the `maestro hooks install` CLI subcommand and
 //! the daemon's first-start auto-install:
@@ -6,40 +6,28 @@
 //! * [`HOOK_SCRIPT`] — the hook itself, written to disk at install time. It
 //!   posts an [`ActivityState`](maestro-protocol) to
 //!   `$MAESTRO_URL/api/sessions/$MAESTRO_SESSION_ID/activity` (#105). The same
-//!   global hook runs in every agent session on the machine, so it exits
+//!   global hook runs in every Claude Code session on the machine, so it exits
 //!   0 and silently when either #103 env var is unset, and it never lets a
 //!   daemon failure escape (short curl timeout, status ignored).
-//! * [`install`] — idempotent registration of that script in one [`Target`]'s
-//!   hook file. Only entries maestro itself wrote (identified by
-//!   [`HOOK_MARKER`]) are touched; every other hook and every other field in
-//!   the file is preserved verbatim.
-//!
-//! One script serves every [`Target`]: Claude Code and Codex read the same
-//! `{"hooks": {Event: [{"hooks": [{"type": "command", "command": …}]}]}}`
-//! shape and hand the hook the same JSON on stdin. Only the file's location
-//! and the event set differ.
+//! * [`install`] — idempotent registration of that script in
+//!   `~/.claude/settings.json`. Only entries maestro itself wrote (identified
+//!   by [`HOOK_MARKER`]) are touched; every other hook and every other field
+//!   in the file is preserved verbatim.
 
 use std::path::Path;
 
 /// Marker substring every maestro-installed hook command carries. The
 /// installer rewrites or removes exactly these entries — nothing else in the
 /// user's settings file.
-///
-/// It still says `claude` although the script now serves every [`Target`]:
-/// the marker is how an install from an older maestro is recognised, and
-/// renaming it would orphan every entry already on disk.
 pub const HOOK_MARKER: &str = "maestro-claude-hook";
 
-/// File name of the installed script (carries [`HOOK_MARKER`]). One script
-/// for every [`Target`] — see the note on [`HOOK_MARKER`] for the name.
+/// File name of the installed script (carries [`HOOK_MARKER`]).
 pub const SCRIPT_FILE_NAME: &str = "maestro-claude-hook.sh";
 
-/// Hook events installed only with the `haiku-autoname` feature (#131), for
-/// every [`Target`] — Claude Code and Codex both spell the event
-/// `UserPromptSubmit` and both put the submitted text in the payload's
-/// `prompt`. The script forwards the whole payload to
-/// `/api/sessions/:id/prompt`, which names a still-provisionally-named
-/// session after its first one.
+/// Hook events installed only with the `haiku-autoname` feature (#131).
+/// `UserPromptSubmit` carries the prompt the user just submitted; the script
+/// forwards the whole payload to `/api/sessions/:id/prompt`, which names a
+/// still-provisionally-named session after its first one.
 #[cfg(feature = "haiku-autoname")]
 pub const PROMPT_EVENTS: [(&str, &str); 1] = [("UserPromptSubmit", "Prompt")];
 
@@ -55,7 +43,7 @@ pub const PROMPT_EVENTS: [(&str, &str); 0] = [];
 /// Claude Code's own name for "the turn ended on an API error"; there is no
 /// failure signal in `Stop` or `SessionEnd` payloads, so those never report
 /// `Error`.
-pub const CLAUDE_EVENTS: [(&str, &str); 5] = [
+pub const HOOK_EVENTS: [(&str, &str); 5] = [
     // Tool starting: the agent is demonstrably producing work, even if the
     // tool itself runs for minutes.
     ("PreToolUse", "Active"),
@@ -70,86 +58,17 @@ pub const CLAUDE_EVENTS: [(&str, &str); 5] = [
     ("StopFailure", "Error"),
 ];
 
-/// Codex hook event → `ActivityState` spelling posted to the daemon.
-///
-/// Codex's event set is close to Claude Code's but not identical: a pending
-/// approval arrives as `PermissionRequest` rather than `Notification`, and
-/// there is no `StopFailure`, so a codex session never reports `Error`.
-pub const CODEX_EVENTS: [(&str, &str); 4] = [
-    ("PreToolUse", "Active"),
-    ("PostToolUse", "Active"),
-    // Codex is blocked on the operator approving a tool call.
-    ("PermissionRequest", "AwaitingInput"),
-    ("Stop", "AwaitingInput"),
-];
-
-/// An agent whose hook file maestro writes into.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum Target {
-    /// `~/.claude/settings.json`.
-    ClaudeCode,
-    /// `~/.codex/hooks.json`. Codex asks the operator to trust a hook it has
-    /// not seen before, so an install here does nothing until they approve it
-    /// once inside codex — maestro never writes that approval itself.
-    Codex,
-}
-
-impl Target {
-    /// Every target an install covers. Both files are written whether or not
-    /// the agent is on the machine: an unused hook file costs nothing, and
-    /// the alternative is a session spawned after the daemon started missing
-    /// the hook because its agent arrived later.
-    pub const ALL: [Target; 2] = [Target::ClaudeCode, Target::Codex];
-
-    /// How the target is named in logs and CLI output.
-    pub fn label(self) -> &'static str {
-        match self {
-            Target::ClaudeCode => "claude-code",
-            Target::Codex => "codex",
-        }
-    }
-
-    /// The file this target's hook entries are registered in, under `home`.
-    pub fn settings_path(self, home: &Path) -> std::path::PathBuf {
-        match self {
-            Target::ClaudeCode => home.join(".claude/settings.json"),
-            Target::Codex => home.join(".codex/hooks.json"),
-        }
-    }
-
-    /// The activity events this target emits.
-    pub fn activity_events(self) -> &'static [(&'static str, &'static str)] {
-        match self {
-            Target::ClaudeCode => &CLAUDE_EVENTS,
-            Target::Codex => &CODEX_EVENTS,
-        }
-    }
-
-    /// Every event installed for this target: its activity events plus, with
-    /// `haiku-autoname` on, the prompt event both agents spell the same way.
-    pub fn events(self) -> impl Iterator<Item = (&'static str, &'static str)> {
-        self.activity_events()
-            .iter()
-            .chain(PROMPT_EVENTS.iter())
-            .copied()
-    }
-}
-
 /// The shipped hook script. POSIX sh so any `/bin/sh` works.
 pub const HOOK_SCRIPT: &str = r#"#!/bin/sh
-# Installed by maestro (#106): report agent activity to its daemon.
-# One script for every agent maestro installs hooks into; the state to post
-# is chosen by the caller, so the two event sets differ only in what is
-# registered where. Exits silently unless running inside a session maestro
-# spawned (#103 env).
+# Installed by maestro (#106): report Claude Code activity to its daemon.
+# Exits silently unless running inside a session maestro spawned (#103 env).
 # Event -> ActivityState mapping:
-#   PreToolUse         -> Active         (tool started; agent is working)
-#   PostToolUse        -> Active         (tool finished)
-#   Notification       -> AwaitingInput  (claude code: permission / idle)
-#   PermissionRequest  -> AwaitingInput  (codex: waiting on an approval)
-#   Stop               -> AwaitingInput  (turn ended; waiting on the user)
-#   StopFailure        -> Error          (claude code: turn ended on an error)
-#   Prompt             -> the payload is forwarded to the prompt route (#131)
+#   PreToolUse    -> Active         (tool started; agent is working)
+#   PostToolUse   -> Active         (tool finished)
+#   Notification  -> AwaitingInput  (permission / idle notice)
+#   Stop          -> AwaitingInput  (turn ended; waiting on the user)
+#   StopFailure   -> Error          (turn ended on an API error)
+#   Prompt        -> the payload is forwarded to the prompt route (#131)
 state="$1"
 [ -n "$MAESTRO_SESSION_ID" ] || exit 0
 [ -n "$MAESTRO_URL" ] || exit 0
@@ -165,15 +84,23 @@ if [ "$state" = "Prompt" ]; then
         >/dev/null 2>&1 || true
     exit 0
 fi
-body="{\"state\":\"$state\"}"
+fields="\"state\":\"$state\""
 # StopFailure payloads carry the outcome in "error". Only a plain enum
 # spelling is reported as the detail — anything else (quotes, backslashes,
 # prose) would risk breaking the JSON body, and the spelling already names
 # the failure.
 detail=$(printf '%s' "$payload" | sed -n 's/.*"error"[[:space:]]*:[[:space:]]*"\([a-z_]*\)".*/\1/p')
 if [ -n "$detail" ]; then
-    body="{\"state\":\"$state\",\"detail\":\"$detail\"}"
+    fields="$fields,\"detail\":\"$detail\""
 fi
+# Every Claude Code hook payload carries its own conversation id (#161).
+# Constrained to a safe charset for the same reason as "detail" above: it is
+# spliced into the JSON body unescaped.
+session_id=$(printf '%s' "$payload" | sed -n 's/.*"session_id"[[:space:]]*:[[:space:]]*"\([A-Za-z0-9_-]*\)".*/\1/p')
+if [ -n "$session_id" ]; then
+    fields="$fields,\"session_id\":\"$session_id\""
+fi
+body="{$fields}"
 curl -fsS --connect-timeout 1 --max-time 2 \
     -H 'Content-Type: application/json' \
     -d "$body" \
@@ -196,29 +123,34 @@ pub fn script_path(home: &Path) -> std::path::PathBuf {
     home.join(".local/share/maestro").join(SCRIPT_FILE_NAME)
 }
 
-/// Whether the file at `settings_path` already carries a maestro hook
-/// (#106). Presence only: an install from an older release answers `true`
-/// even when it is missing events this build ships — see [`is_current`].
+/// The user-level Claude Code settings file for a given home directory.
+pub fn settings_path(home: &Path) -> std::path::PathBuf {
+    home.join(".claude/settings.json")
+}
+
+/// Whether `settings_path` already carries a maestro hook (#106). Presence
+/// only: an install from an older release answers `true` even when it is
+/// missing events this build ships — see [`is_current`].
 pub fn is_installed(settings_path: &Path) -> bool {
     settings_json(settings_path)
         .map(|root| find_maestro_commands(&root).next().is_some())
         .unwrap_or(false)
 }
 
-/// Whether what is on disk is what this build ships for `target`: the script
-/// at `script_path` byte-for-byte, and exactly one settings entry per one of
-/// the target's [`Target::events`], pointing at that script.
+/// Whether what is on disk is what this build ships: the script at
+/// `script_path` byte-for-byte, and exactly one settings entry per event in
+/// [`HOOK_EVENTS`] and [`PROMPT_EVENTS`], pointing at that script.
 ///
-/// This is the upgrade question, asked per [`Target`]. A maestro that gains
-/// an event — #131 added `UserPromptSubmit` long after #106 had installed
-/// itself — leaves every existing user with a present but incomplete
-/// install, which [`is_installed`] cannot tell apart from a current one.
-pub fn is_current(target: Target, settings_path: &Path, script_path: &Path) -> bool {
+/// This is the upgrade question. A maestro that gains an event — #131 added
+/// `UserPromptSubmit` long after #106 had installed itself — leaves every
+/// existing user with a present but incomplete install, which
+/// [`is_installed`] cannot tell apart from a current one.
+pub fn is_current(settings_path: &Path, script_path: &Path) -> bool {
     if std::fs::read_to_string(script_path).ok().as_deref() != Some(HOOK_SCRIPT) {
         return false;
     }
     settings_json(settings_path)
-        .map(|root| maestro_entries(&root) == expected_entries(target, script_path))
+        .map(|root| maestro_entries(&root) == expected_entries(script_path))
         .unwrap_or(false)
 }
 
@@ -249,13 +181,14 @@ fn maestro_entries(root: &serde_json::Value) -> Vec<(String, String)> {
     found
 }
 
-/// What [`install`] writes for `target` and `script_path`, in the same shape.
-fn expected_entries(target: Target, script_path: &Path) -> Vec<(String, String)> {
-    let mut want: Vec<(String, String)> = target
-        .events()
+/// What [`install`] writes for `script_path`, in the same shape.
+fn expected_entries(script_path: &Path) -> Vec<(String, String)> {
+    let mut want: Vec<(String, String)> = HOOK_EVENTS
+        .iter()
+        .chain(PROMPT_EVENTS.iter())
         .map(|(event, state)| {
             (
-                event.to_string(),
+                (*event).to_string(),
                 format!("{} {state}", script_path.display()),
             )
         })
@@ -282,40 +215,28 @@ pub fn write_script(path: &Path) -> Result<(), HooksError> {
     Ok(())
 }
 
-/// Install the full hook setup for one target under `home`: write the script
-/// under `.local/share/maestro/` and register it in the target's hook file.
+/// Install the full hook setup for `home`: write the script under
+/// `.local/share/maestro/` and register it in `.claude/settings.json`.
 /// Idempotent; returns whether anything changed on disk.
-pub fn install_target(target: Target, home: &Path) -> Result<bool, HooksError> {
+pub fn install_for_home(home: &Path) -> Result<bool, HooksError> {
     let script = script_path(home);
-    let settings = target.settings_path(home);
+    let settings = settings_path(home);
     // A script left over from an older release counts as a change even when
     // the settings entries pointing at it are already right.
-    let changed = !is_current(target, &settings, &script);
+    let changed = !is_current(&settings, &script);
     write_script(&script)?;
-    install(target, &settings, &script)?;
+    install(&settings, &script)?;
     Ok(changed)
 }
 
-/// Install for every [`Target::ALL`], reporting each one separately. One
-/// target failing — an unwritable file, unparseable JSON — never stops the
-/// others: an agent whose hook could not be written is one agent without
-/// activity reporting, not a failed install.
-pub fn install_for_home(home: &Path) -> Vec<(Target, Result<bool, HooksError>)> {
-    Target::ALL
-        .iter()
-        .map(|&target| (target, install_target(target, home)))
-        .collect()
-}
-
-/// Register the hook command for every one of `target`'s [`Target::events`]
-/// in the settings file at `settings_path`. Idempotent: existing maestro
-/// entries are updated in place wherever they sit, stale ones removed,
-/// duplicates folded; every non-maestro entry and every unrelated top-level
-/// field survives.
+/// Register the hook command for every event in [`HOOK_EVENTS`] in the
+/// settings file at `settings_path`. Idempotent: existing maestro entries are
+/// updated in place wherever they sit, stale ones removed, duplicates folded;
+/// every non-maestro entry and every unrelated top-level field survives.
 ///
 /// Never inspects or writes anywhere but `settings_path` — callers pass the
 /// user's real home or a temp one in tests, never a repository.
-pub fn install(target: Target, settings_path: &Path, script_path: &Path) -> Result<(), HooksError> {
+pub fn install(settings_path: &Path, script_path: &Path) -> Result<(), HooksError> {
     let mut root = settings_json(settings_path)?;
 
     // Strip every maestro entry wherever it currently sits, so an older
@@ -323,7 +244,7 @@ pub fn install(target: Target, settings_path: &Path, script_path: &Path) -> Resu
     strip_maestro_entries(&mut root);
 
     let hooks = ensure_object(&mut root, "hooks");
-    for (event, state) in target.events() {
+    for (event, state) in HOOK_EVENTS.iter().chain(PROMPT_EVENTS.iter()).copied() {
         let groups = ensure_array(hooks, event);
         let mut group = serde_json::Map::new();
         group.insert(

crates/maestro-hooks/src/tests.rs

@@ -1,24 +1,15 @@
 //! Tests for the shipped hook script (run as a real `/bin/sh` subprocess)
 //! and the settings-file installer. Everything happens under a temp `$HOME`;
-//! the developer's own `~/.claude/settings.json` and `~/.codex/hooks.json`
-//! are never touched.
+//! the developer's own `~/.claude/settings.json` is never touched.
 
 use std::io::{Read, Write};
 use std::process::{Command, Stdio};
 
 use super::*;
 
-/// How many commands one install writes for a target: its activity events,
-/// plus the prompt event when `haiku-autoname` is on (#131).
-fn installed_events(target: Target) -> usize {
-    target.events().count()
-}
-
-/// The Claude Code hook file under a temp home. Most installer tests only
-/// need one target, and this is the one they were written against.
-fn settings_path(home: &Path) -> std::path::PathBuf {
-    Target::ClaudeCode.settings_path(home)
-}
+/// How many commands one install writes: every activity event, plus the
+/// prompt event when `haiku-autoname` is on (#131).
+const INSTALLED_EVENTS: usize = HOOK_EVENTS.len() + PROMPT_EVENTS.len();
 
 fn sh(script: &str, args: &[&str], envs: &[(&str, &str)], payload: &[u8]) -> std::process::Output {
     let mut cmd = Command::new("/bin/sh");
@@ -79,7 +70,7 @@ fn owned_envs<'a>(envs: &'a [(&'static str, String)]) -> Vec<(&'static str, &'a
 /// exit 0, no output, stdin drained.
 #[test]
 fn script_exits_silently_without_maestro_env() {
-    for (event, _) in CLAUDE_EVENTS {
+    for (event, _) in HOOK_EVENTS {
         let out = sh(HOOK_SCRIPT, &[event], &[], br#"{"session_id":"x"}"#);
         assert!(out.status.success(), "{event:?}: {:?}", out.stderr);
         assert!(out.stdout.is_empty(), "{event:?}: {:?}", out.stdout);
@@ -112,7 +103,7 @@ fn script_posts_mapped_state_to_the_activity_endpoint() {
 /// Every event maps to the state the contract specifies.
 #[test]
 fn event_state_mapping_matches_the_contract() {
-    let map: std::collections::HashMap<&str, &str> = CLAUDE_EVENTS.into_iter().collect();
+    let map: std::collections::HashMap<&str, &str> = HOOK_EVENTS.into_iter().collect();
     assert_eq!(map["PreToolUse"], "Active");
     assert_eq!(map["PostToolUse"], "Active");
     assert_eq!(map["Notification"], "AwaitingInput");
@@ -137,6 +128,41 @@ fn script_reports_the_error_spelling_as_detail() {
     assert!(request.contains(r#""detail":"rate_limit""#), "{request}");
 }
 
+/// #161: the payload's own `session_id` — the agent's conversation id — is
+/// parsed out and forwarded in the activity body, so the daemon can persist
+/// it on the session.
+#[test]
+fn script_forwards_the_payloads_session_id_in_the_activity_body() {
+    let request = capture_request(|url| {
+        sh(
+            HOOK_SCRIPT,
+            &["Active"],
+            &owned_envs(&session_envs(&url)),
+            br#"{"session_id":"conv-abc123","hook_event_name":"PreToolUse"}"#,
+        )
+    });
+    assert!(request.contains(r#""state":"Active""#), "{request}");
+    assert!(
+        request.contains(r#""session_id":"conv-abc123""#),
+        "{request}"
+    );
+}
+
+/// A payload without a `session_id` (or one with an unexpected shape) must
+/// never produce a broken body — no `session_id` field is posted.
+#[test]
+fn script_posts_no_session_id_when_the_payload_has_none() {
+    let request = capture_request(|url| {
+        sh(
+            HOOK_SCRIPT,
+            &["AwaitingInput"],
+            &owned_envs(&session_envs(&url)),
+            br#"{"hook_event_name":"Stop","stop_hook_active":false}"#,
+        )
+    });
+    assert!(!request.contains("session_id"), "{request}");
+}
+
 /// An `error` value that is not a plain enum spelling (or a payload without
 /// one at all) must never produce a broken body — no detail is posted.
 #[test]
@@ -212,10 +238,10 @@ fn fresh_install_registers_every_event() {
     let dir = tempfile::tempdir().unwrap();
     let home = dir.path();
     write_script(&script_path(home)).unwrap();
-    install(Target::ClaudeCode, &settings_path(home), &script_path(home)).unwrap();
+    install(&settings_path(home), &script_path(home)).unwrap();
 
     let cmds = installed_commands(&settings_path(home));
-    assert_eq!(cmds.len(), installed_events(Target::ClaudeCode));
+    assert_eq!(cmds.len(), INSTALLED_EVENTS);
     let joined = cmds.join("\n");
     assert_eq!(joined.matches("Active").count(), 2);
     assert!(joined.contains("Error"));
@@ -230,15 +256,15 @@ fn fresh_install_registers_every_event() {
 fn install_is_idempotent() {
     let dir = tempfile::tempdir().unwrap();
     let home = dir.path();
-    install(Target::ClaudeCode, &settings_path(home), &script_path(home)).unwrap();
+    install(&settings_path(home), &script_path(home)).unwrap();
     let once = std::fs::read_to_string(settings_path(home)).unwrap();
 
-    install(Target::ClaudeCode, &settings_path(home), &script_path(home)).unwrap();
+    install(&settings_path(home), &script_path(home)).unwrap();
     let twice = std::fs::read_to_string(settings_path(home)).unwrap();
     assert_eq!(once, twice);
     assert_eq!(
         installed_commands(&settings_path(home)).len(),
-        installed_events(Target::ClaudeCode)
+        INSTALLED_EVENTS
     );
 }
 
@@ -266,12 +292,12 @@ fn install_updates_an_older_maestro_hook_in_place() {
         .path()
         .join(".local/share/maestro")
         .join(SCRIPT_FILE_NAME);
-    install(Target::ClaudeCode, &settings, &new_script).unwrap();
+    install(&settings, &new_script).unwrap();
 
     let cmds = installed_commands(&settings);
     assert_eq!(
         cmds.len(),
-        installed_events(Target::ClaudeCode),
+        INSTALLED_EVENTS,
         "old entry replaced, not kept: {cmds:?}"
     );
     assert!(!cmds.iter().any(|c| c == old_script));
@@ -307,7 +333,7 @@ fn install_preserves_foreign_hooks_and_removes_stale_maestro_ones() {
         .path()
         .join(".local/share/maestro")
         .join(SCRIPT_FILE_NAME);
-    install(Target::ClaudeCode, &settings, &new_script).unwrap();
+    install(&settings, &new_script).unwrap();
 
     let root: serde_json::Value =
         serde_json::from_str(&std::fs::read_to_string(&settings).unwrap()).unwrap();
@@ -320,7 +346,7 @@ fn install_preserves_foreign_hooks_and_removes_stale_maestro_ones() {
     let cmds = installed_commands(&settings);
     assert_eq!(
         cmds.iter().filter(|c| c.contains(HOOK_MARKER)).count(),
-        installed_events(Target::ClaudeCode),
+        INSTALLED_EVENTS,
         "{cmds:?}"
     );
 }
@@ -330,15 +356,9 @@ fn install_preserves_foreign_hooks_and_removes_stale_maestro_ones() {
 fn is_installed_tracks_reality() {
     let dir = tempfile::tempdir().unwrap();
     let home = dir.path();
-    for target in Target::ALL {
-        assert!(!is_installed(&target.settings_path(home)));
-    }
-    for (_, result) in install_for_home(home) {
-        result.unwrap();
-    }
-    for target in Target::ALL {
-        assert!(is_installed(&target.settings_path(home)));
-    }
+    assert!(!is_installed(&settings_path(home)));
+    install_for_home(home).unwrap();
+    assert!(is_installed(&settings_path(home)));
 }
 
 /// The full home-level install leaves the script executable.
@@ -346,9 +366,7 @@ fn is_installed_tracks_reality() {
 fn install_for_home_writes_an_executable_script() {
     let dir = tempfile::tempdir().unwrap();
     let home = dir.path();
-    for (_, result) in install_for_home(home) {
-        result.unwrap();
-    }
+    install_for_home(home).unwrap();
     #[cfg(unix)]
     {
         use std::os::unix::fs::PermissionsExt;
@@ -367,7 +385,7 @@ fn install_for_home_writes_an_executable_script() {
 fn install_registers_the_prompt_event() {
     let dir = tempfile::tempdir().unwrap();
     let home = dir.path();
-    install(Target::ClaudeCode, &settings_path(home), &script_path(home)).unwrap();
+    install(&settings_path(home), &script_path(home)).unwrap();
 
     let root: serde_json::Value =
         serde_json::from_str(&std::fs::read_to_string(settings_path(home)).unwrap()).unwrap();
@@ -384,7 +402,7 @@ fn install_registers_the_prompt_event() {
 fn install_registers_no_prompt_event_without_the_feature() {
     let dir = tempfile::tempdir().unwrap();
     let home = dir.path();
-    install(Target::ClaudeCode, &settings_path(home), &script_path(home)).unwrap();
+    install(&settings_path(home), &script_path(home)).unwrap();
 
     let root: serde_json::Value =
         serde_json::from_str(&std::fs::read_to_string(settings_path(home)).unwrap()).unwrap();
@@ -453,12 +471,8 @@ fn the_script_posts_a_prompt_payload_unchanged() {
 fn is_current_rejects_an_install_missing_an_event() {
     let dir = tempfile::tempdir().unwrap();
     let home = dir.path();
-    install_target(Target::ClaudeCode, home).unwrap();
-    assert!(is_current(
-        Target::ClaudeCode,
-        &settings_path(home),
-        &script_path(home)
-    ));
+    install_for_home(home).unwrap();
+    assert!(is_current(&settings_path(home), &script_path(home)));
 
     // Drop one event, as an older install would have left the file.
     let mut root: serde_json::Value =
@@ -471,11 +485,7 @@ fn is_current_rejects_an_install_missing_an_event() {
     .unwrap();
 
     assert!(is_installed(&settings_path(home)));
-    assert!(!is_current(
-        Target::ClaudeCode,
-        &settings_path(home),
-        &script_path(home)
-    ));
+    assert!(!is_current(&settings_path(home), &script_path(home)));
 }
 
 /// A settings file that is complete but points at a script from an older
@@ -484,13 +494,9 @@ fn is_current_rejects_an_install_missing_an_event() {
 fn is_current_rejects_a_stale_script() {
     let dir = tempfile::tempdir().unwrap();
     let home = dir.path();
-    install_target(Target::ClaudeCode, home).unwrap();
+    install_for_home(home).unwrap();
     std::fs::write(script_path(home), "#!/bin/sh\nexit 0\n").unwrap();
-    assert!(!is_current(
-        Target::ClaudeCode,
-        &settings_path(home),
-        &script_path(home)
-    ));
+    assert!(!is_current(&settings_path(home), &script_path(home)));
 }
 
 /// Nothing installed at all is not current.
@@ -498,93 +504,18 @@ fn is_current_rejects_a_stale_script() {
 fn is_current_rejects_a_missing_install() {
     let dir = tempfile::tempdir().unwrap();
     let home = dir.path();
-    assert!(!is_current(
-        Target::ClaudeCode,
-        &settings_path(home),
-        &script_path(home)
-    ));
+    assert!(!is_current(&settings_path(home), &script_path(home)));
 }
 
-/// `install_target` reports a stale script as a change, even when the
+/// `install_for_home` reports a stale script as a change, even when the
 /// settings entries pointing at it already read correctly.
 #[test]
-fn install_target_reports_a_stale_script_as_a_change() {
+fn install_for_home_reports_a_stale_script_as_a_change() {
     let dir = tempfile::tempdir().unwrap();
     let home = dir.path();
-    assert!(install_target(Target::ClaudeCode, home).unwrap());
-    assert!(!install_target(Target::ClaudeCode, home).unwrap());
+    assert!(install_for_home(home).unwrap());
+    assert!(!install_for_home(home).unwrap());
 
     std::fs::write(script_path(home), "#!/bin/sh\nexit 0\n").unwrap();
-    assert!(install_target(Target::ClaudeCode, home).unwrap());
-}
-
-/// Codex is hooked in its own file, with its own event set: the two agents
-/// share the script but not the events, so neither file carries the other's
-/// spellings (#131 follow-up — a codex session was never named because
-/// nothing installed its `UserPromptSubmit` hook).
-#[test]
-fn each_target_gets_its_own_file_and_events() {
-    let dir = tempfile::tempdir().unwrap();
-    let home = dir.path();
-    for (_, result) in install_for_home(home) {
-        result.unwrap();
-    }
-
-    let claude = events_in(&Target::ClaudeCode.settings_path(home));
-    let codex = events_in(&Target::Codex.settings_path(home));
-    assert_eq!(
-        Target::Codex.settings_path(home),
-        home.join(".codex/hooks.json")
-    );
-
-    // Claude Code's failure signal has no codex equivalent, and codex's
-    // approval notice is spelled differently.
-    assert!(claude.contains(&"StopFailure".to_string()));
-    assert!(claude.contains(&"Notification".to_string()));
-    assert!(!codex.contains(&"StopFailure".to_string()));
-    assert!(!codex.contains(&"Notification".to_string()));
-    assert!(codex.contains(&"PermissionRequest".to_string()));
-
-    // Both report work and both report a finished turn.
-    for event in ["PreToolUse", "PostToolUse", "Stop"] {
-        assert!(claude.contains(&event.to_string()), "claude {event}");
-        assert!(codex.contains(&event.to_string()), "codex {event}");
-    }
-
-    assert_eq!(
-        installed_commands(&Target::Codex.settings_path(home)).len(),
-        installed_events(Target::Codex)
-    );
-}
-
-/// #131: a codex session names itself the same way a Claude Code one does —
-/// same event spelling, same script, same `Prompt` argument.
-#[cfg(feature = "haiku-autoname")]
-#[test]
-fn codex_reports_its_first_prompt_too() {
-    let dir = tempfile::tempdir().unwrap();
-    let home = dir.path();
-    install_target(Target::Codex, home).unwrap();
-
-    let root: serde_json::Value =
-        serde_json::from_str(&std::fs::read_to_string(Target::Codex.settings_path(home)).unwrap())
-            .unwrap();
-    let cmd = root["hooks"]["UserPromptSubmit"][0]["hooks"][0]["command"]
-        .as_str()
-        .unwrap()
-        .to_string();
-    assert!(cmd.ends_with(" Prompt"), "{cmd}");
-    assert!(cmd.contains(SCRIPT_FILE_NAME));
-}
-
-/// Every event name a settings file registers a maestro hook under.
-fn events_in(settings: &Path) -> Vec<String> {
-    serde_json::from_str::<serde_json::Value>(&std::fs::read_to_string(settings).unwrap())
-        .unwrap()
-        .get("hooks")
-        .and_then(|h| h.as_object())
-        .into_iter()
-        .flatten()
-        .map(|(event, _)| event.clone())
-        .collect()
+    assert!(install_for_home(home).unwrap());
 }

crates/maestro-protocol/src/client.rs

@@ -17,7 +17,7 @@ use crate::routes::{self, UrlError};
 use crate::{
     ApiError, BranchInfo, CreateSessionRequest, DaemonInfo, DirListing, ErrorInfo, GitRoot,
     Project, RecentDirs, RenameSessionRequest, ReportActivityRequest, SendInputRequest, Session,
-    SetFocusRequest, StructuredApprovalDecision, StructuredPromptRequest,
+    SetFocusRequest,
 };
 
 /// Time budget for establishing a TCP connection to the daemon.
@@ -105,11 +105,6 @@ impl DaemonClient {
         Ok(routes::attach_url(&self.base, id)?)
     }
 
-    /// `WS /api/structured/:id` URL for this daemon.
-    pub fn structured_url(&self, id: Uuid) -> Result<String, ClientError> {
-        Ok(routes::structured_url(&self.base, id)?)
-    }
-
     // -- typed calls --------------------------------------------------------
 
     pub async fn list_sessions(&self) -> Result<Vec<Session>, ClientError> {
@@ -184,57 +179,6 @@ impl DaemonClient {
         Ok(())
     }
 
-    /// Send one prompt to a structured session. The daemon rejects a second
-    /// prompt while the preceding ACP turn is still active.
-    pub async fn send_structured_prompt(&self, id: Uuid, prompt: &str) -> Result<(), ClientError> {
-        let req = StructuredPromptRequest {
-            prompt: prompt.to_string(),
-        };
-        let resp = self
-            .send(
-                Method::POST,
-                &routes::structured_prompt(id),
-                &[],
-                Some(&req),
-            )
-            .await?;
-        check(resp).await?;
-        Ok(())
-    }
-
-    /// Cancel the structured session's active ACP turn.
-    pub async fn cancel_structured_turn(&self, id: Uuid) -> Result<(), ClientError> {
-        let resp = self
-            .send(
-                Method::POST,
-                &routes::structured_cancel(id),
-                &[],
-                None::<&()>,
-            )
-            .await?;
-        check(resp).await?;
-        Ok(())
-    }
-
-    /// Resolve the currently pending structured-session permission request.
-    pub async fn resolve_structured_approval(
-        &self,
-        id: Uuid,
-        nonce: &str,
-        decision: StructuredApprovalDecision,
-    ) -> Result<(), ClientError> {
-        let resp = self
-            .send(
-                Method::POST,
-                &routes::structured_approval(id, nonce),
-                &[],
-                Some(&decision),
-            )
-            .await?;
-        check(resp).await?;
-        Ok(())
-    }
-
     pub async fn daemon_info(&self) -> Result<DaemonInfo, ClientError> {
         self.get(routes::INFO, &[]).await
     }

crates/maestro-protocol/src/display.rs

@@ -166,32 +166,45 @@ pub fn merge_linear<T>(folder: TreeFolder<T>) -> TreeFolder<T> {
     cur
 }
 
+/// Command wrappers that run another program: the program is what follows.
+const WRAPPERS: [&str; 8] = [
+    "sudo", "env", "npx", "bunx", "uvx", "pnpm", "yarn", "command",
+];
+
 /// The program a command line runs, basenamed and stripped of its arguments —
 /// what a session card shows per `docs/SIDEBAR.md`, which names the program
 /// and never its flags. Leading `FOO=bar` assignments and wrappers (`sudo`,
-/// `npx`, `pnpm dlx`, …) are looked through, and quoting/escaping is honoured
-/// (never evaluated — no `$var`/`` `cmd` ``/`$(cmd)` expansion). A command a
-/// shell would need real grammar for (pipelines, `&&`/`;`, redirections,
-/// substitution, an unterminated quote) falls back to the naive first word
-/// rather than guessing through it (#199). Mirrors the web's `splitCommand`.
+/// `npx`, `pnpm dlx`, …) are looked through. Mirrors the web's `splitCommand`.
 pub fn command_program(command: &str) -> String {
-    match resolve(command) {
-        Some(r) => match r.words.get(r.program_index) {
-            Some(word) => basename(word).to_string(),
-            // Nothing but wrappers and assignments: say what was there
-            // rather than rendering an empty fragment.
-            None => command.trim().to_string(),
-        },
-        None => legacy_first_word(command),
+    let words: Vec<&str> = command.split_whitespace().collect();
+    let mut i = 0;
+    while i < words.len() {
+        let word = words[i];
+        if is_env_assignment(word) {
+            i += 1;
+            continue;
+        }
+        let wrapper = basename(word).to_lowercase();
+        if WRAPPERS.contains(&wrapper.as_str()) {
+            i += 1;
+            if (wrapper == "pnpm" || wrapper == "yarn") && words.get(i) == Some(&"dlx") {
+                i += 1;
+            }
+            continue;
+        }
+        break;
+    }
+    match words.get(i) {
+        Some(word) => basename(word).to_string(),
+        // Nothing but wrappers and assignments: say what was there rather than
+        // rendering an empty fragment.
+        None => command.trim().to_string(),
     }
 }
 
 /// Program name (already basenamed and lowercased) -> the tool id its mark
 /// stands for. Mirrors the web's `BY_PROGRAM` in `web/src/toolIcon.ts`;
 /// recognition is deliberately narrow, so an unrecognised program has no tool.
-/// `claude-code-acp` — the daemon's actual structured-session child — is
-/// deliberately absent: the daemon launches it directly and ignores
-/// `req.command`, so it is never itself a valid user-facing launch form.
 const BY_PROGRAM: [(&str, &str); 17] = [
     ("claude", "claude"),
     ("claude-code", "claude"),
@@ -213,500 +226,29 @@ const BY_PROGRAM: [(&str, &str); 17] = [
 ];
 
 /// The tool id a command line's icon stands for (`claude`, `codex`,
-/// `opencode`, ...), or `None` when the program is not one we have a mark for
-/// — including a command line [`resolve`] would only guess at. The command
-/// bar matches this field (`docs/COMMAND-BAR.md`), so it must name the same
-/// tools the web's `splitCommand().tool` does.
+/// `opencode`, ...), or `None` when the program is not one we have a mark for.
+/// The command bar matches this field (`docs/COMMAND-BAR.md`), so it must name
+/// the same tools the web's `splitCommand().tool` does.
 pub fn command_tool(command: &str) -> Option<&'static str> {
-    let r = resolve(command)?;
-    let program = basename(r.words.get(r.program_index)?).to_lowercase();
+    let program = command_program(command).to_lowercase();
     BY_PROGRAM
         .iter()
         .find(|(name, _)| *name == program)
         .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).
-struct Resolution {
-    words: Vec<String>,
-    program_index: usize,
-}
-
-/// Tokenize `command` and walk past leading `FOO=bar` assignments and known
-/// wrapper forms (interleaved in any order/count) to find the program. An
-/// assignment run is only consumed at the very start of the line or right
-/// after a wrapper whose own semantics accept one there ([`Wrapper::accepts_assignment`]) —
-/// `command FOO=1 claude` and `nohup FOO=1 claude` stop at `FOO=1` rather than
-/// skipping to `claude`, since `command`/`nohup` just exec their next argument
-/// as the program, they don't setenv from an assignment-shaped one (#199).
-/// `None` when [`tokenize`] can't safely make sense of the line at all.
-fn resolve(command: &str) -> Option<Resolution> {
-    let words = tokenize(command)?;
-    let refs: Vec<&str> = words.iter().map(|w| w.text.as_str()).collect();
-    let mut i = 0;
-    let mut assignment_allowed = true;
-    loop {
-        if assignment_allowed {
-            while matches!(words.get(i), Some(word) if is_env_assignment(word)) {
-                i += 1;
-            }
-        }
-        let Some(word) = words.get(i) else { break };
-        let wrapper = basename(&word.text).to_lowercase();
-        let Some(w) = wrapper_resolver(&wrapper) else {
-            break;
-        };
-        match (w.resolve)(&refs, i) {
-            Some(next) if next > i => {
-                i = next;
-                assignment_allowed = w.accepts_assignment;
-            }
-            // Not a form of the wrapper we recognise (an unknown option, or
-            // — for `pnpm`/`yarn`/`bun` — no `dlx`/`x` subcommand behind it):
-            // the wrapper word itself is the program, not a launcher.
-            _ => break,
-        }
-    }
-    Some(Resolution {
-        words: words.into_iter().map(|w| w.text).collect(),
-        program_index: i,
-    })
-}
-
-/// The naive "first whitespace word, basenamed" reading used only when
-/// [`tokenize`] rejects the line outright — still something sane to show,
-/// never a wrapper/tool match to act on.
-fn legacy_first_word(command: &str) -> String {
-    match command.split_whitespace().next() {
-        Some(word) => basename(word).to_string(),
-        None => command.trim().to_string(),
-    }
-}
-
-/// One token from [`tokenize`]: its dequoted text, and — when both the name
-/// and `=` were entirely unquoted/unescaped in the source — the byte length
-/// of the name. Quoting or escaping either (`"FOO"=1`, `F\OO=1`, `FOO\=1`)
-/// makes the word an executable named `FOO=1`; quoting/escaping only the value
-/// preserves the assignment, matching Bash's assignment-word grammar (#199).
-#[derive(Debug, Clone, PartialEq, Eq)]
-struct Word {
-    text: String,
-    plain_eq: Option<usize>,
-}
-
-/// Word-split `command` the way a shell would (honouring `'…'`, `"…"` and
-/// `\` quoting/escaping — POSIX quote *removal*, not evaluation) and return
-/// `None` the moment it needs real shell grammar this resolver doesn't
-/// attempt: a pipeline/list operator (`|`, `&`, `;`, `<`, `>`), a subshell or
-/// substitution (`(`, `)`, `` ` ``, `$(`), an unescaped newline (a command
-/// separator, like `;` — #199), or an unterminated quote/escape. Never
-/// expands `$var`/`` `cmd` ``/`$(cmd)` — a bare `$` is kept literal. A
-/// backslash immediately before a newline, quoted or not, is a line
-/// continuation: removed entirely rather than embedding the newline or
-/// ending the word (#199).
-fn tokenize(command: &str) -> Option<Vec<Word>> {
-    let mut words = Vec::new();
-    let mut current = String::new();
-    let mut has_current = false;
-    let mut plain_eq: Option<usize> = None;
-    let mut assignment_name_is_plain = true;
-    let mut chars = command.chars().peekable();
-
-    while let Some(c) = chars.next() {
-        match c {
-            ' ' | '\t' | '\r' => {
-                if has_current {
-                    words.push(Word {
-                        text: std::mem::take(&mut current),
-                        plain_eq: plain_eq.take(),
-                    });
-                    has_current = false;
-                    assignment_name_is_plain = true;
-                }
-            }
-            '\n' => return None,
-            '|' | '&' | ';' | '<' | '>' | '(' | ')' | '`' => return None,
-            '$' if chars.peek() == Some(&'(') => return None,
-            '\'' => {
-                has_current = true;
-                if plain_eq.is_none() {
-                    assignment_name_is_plain = false;
-                }
-                loop {
-                    match chars.next() {
-                        Some('\'') => break,
-                        Some(c2) => current.push(c2),
-                        None => return None, // unterminated single quote
-                    }
-                }
-            }
-            '"' => {
-                has_current = true;
-                if plain_eq.is_none() {
-                    assignment_name_is_plain = false;
-                }
-                loop {
-                    match chars.next() {
-                        Some('"') => break,
-                        Some('\\') => match chars.next() {
-                            Some(c2 @ ('"' | '\\' | '$' | '`')) => current.push(c2),
-                            Some('\n') => {} // line continuation, removed entirely
-                            Some(c2) => {
-                                current.push('\\');
-                                current.push(c2);
-                            }
-                            None => return None, // trailing backslash
-                        },
-                        Some(c2) => current.push(c2),
-                        None => return None, // unterminated double quote
-                    }
-                }
-            }
-            '\\' => match chars.next() {
-                Some('\n') => {} // line continuation, removed entirely
-                Some(c2) => {
-                    has_current = true;
-                    if plain_eq.is_none() {
-                        assignment_name_is_plain = false;
-                    }
-                    current.push(c2);
-                }
-                None => return None, // trailing backslash
-            },
-            other => {
-                has_current = true;
-                if other == '=' && plain_eq.is_none() && assignment_name_is_plain {
-                    plain_eq = Some(current.len());
-                }
-                current.push(other);
-            }
-        }
-    }
-    if has_current {
-        words.push(Word {
-            text: current,
-            plain_eq,
-        });
-    }
-    Some(words)
-}
-
-/// A wrapper's known `-`/`--` options: which take no value, and which
-/// consume either a following word or a `--flag=value` as theirs. A
-/// `-`-prefixed word this table doesn't know halts resolution rather than
-/// guessing past it (#199) — callers read that as [`OptionTable::consume`]
-/// returning `None`.
-struct OptionTable {
-    flags: &'static [&'static str],
-    valued: &'static [&'static str],
-    /// Whether this wrapper's short options may be combined (`-iv`) or take
-    /// an attached value (`-uroot`), the way real getopt-based tools do
-    /// (#199). JS-toolchain wrappers (`npx`, `pnpm`, `yarn`, bun's `x`/
-    /// `dlx`) don't get this — guessing at bundling they don't actually
-    /// support would resolve through options they'd reject outright.
-    bundles_short_options: bool,
-}
-
-impl OptionTable {
-    /// Consume this table's options starting at `words[i]`, returning the
-    /// index just past them (which may equal `i` if there are none) — or
-    /// `None` on an option this table doesn't recognise, or a valued option
-    /// missing its operand.
-    fn consume(&self, words: &[&str], mut i: usize) -> Option<usize> {
-        loop {
-            let Some(&word) = words.get(i) else {
-                return Some(i);
-            };
-            if word == "--" {
-                return Some(i + 1);
-            }
-            if word == "-" || !word.starts_with('-') {
-                return Some(i);
-            }
-            if let Some((flag, value)) = word.split_once('=') {
-                return if self.valued.contains(&flag) && !value.is_empty() {
-                    i += 1;
-                    continue;
-                } else {
-                    None
-                };
-            }
-            if self.flags.contains(&word) {
-                i += 1;
-                continue;
-            }
-            if self.valued.contains(&word) {
-                let value = words.get(i + 1)?;
-                if value.is_empty() || value.starts_with('-') {
-                    return None;
-                }
-                i += 2;
-                continue;
-            }
-            if self.bundles_short_options
-                && !word.starts_with("--")
-                && word.len() > 2
-                && self.matches_short_cluster(word)
-            {
-                i += 1;
-                continue;
-            }
-            return None;
-        }
-    }
-
-    /// `-iv` (bundled boolean short flags) or `-uroot` (a valued short
-    /// option with its value attached) — getopt's traditional short-option
-    /// forms. `false` the moment a character isn't a short option this
-    /// table knows, or a valued one ends the word with no attached value
-    /// left to be its operand (#199: rejected rather than guessed to come
-    /// from the next word instead).
-    fn matches_short_cluster(&self, word: &str) -> bool {
-        if !word.is_ascii() {
-            return false;
-        }
-        let bytes = word.as_bytes();
-        let mut buf = [b'-', 0];
-        let mut idx = 1;
-        while idx < bytes.len() {
-            buf[1] = bytes[idx];
-            let short = std::str::from_utf8(&buf).expect("ascii buffer");
-            if self.flags.contains(&short) {
-                idx += 1;
-                continue;
-            }
-            if self.valued.contains(&short) {
-                return idx + 1 < bytes.len();
-            }
-            return false;
-        }
-        true
-    }
-}
-
-const NO_OPTIONS: OptionTable = OptionTable {
-    flags: &[],
-    valued: &[],
-    bundles_short_options: false,
-};
-
-const ENV_OPTS: OptionTable = OptionTable {
-    flags: &[
-        "-i",
-        "--ignore-environment",
-        "-0",
-        "--null",
-        "-v",
-        "--debug",
-    ],
-    valued: &["-u", "--unset", "-C", "--chdir"],
-    bundles_short_options: true,
-};
-
-const SUDO_OPTS: OptionTable = OptionTable {
-    flags: &[
-        "-i",
-        "--login",
-        "-n",
-        "--non-interactive",
-        "-E",
-        "--preserve-env",
-        "-H",
-        "--set-home",
-        "-A",
-        "--askpass",
-        "-b",
-        "--background",
-        "-k",
-        "--reset-timestamp",
-        "-K",
-        "--remove-timestamp",
-        "-S",
-        "--stdin",
-    ],
-    valued: &["-u", "--user", "-g", "--group"],
-    bundles_short_options: true,
-};
-
-/// `-v`/`-V` only print what would run — they never execute it — so
-/// resolving through them would claim a program runs that `command` never
-/// launches (#199). Only `-p`, which still executes normally, is safe to
-/// look through.
-const COMMAND_BUILTIN_OPTS: OptionTable = OptionTable {
-    flags: &["-p"],
-    valued: &[],
-    bundles_short_options: true,
-};
-
-/// The bash *keyword* `time` only ever parses `-p` (POSIX output format);
-/// `-o`/`-v`/`-a`/`-f`/`--verbose`/... belong to the external GNU
-/// `/usr/bin/time`, a different program a bare `time` word doesn't
-/// necessarily name. Assuming them here would be guessing which `time`
-/// resolves (#199).
-fn resolve_time(words: &[&str], i: usize) -> Option<usize> {
-    let mut next = i + 1;
-    if words.get(next) == Some(&"-p") {
-        next += 1;
-    }
-    if words.get(next) == Some(&"--") {
-        next += 1;
-    }
-    match words.get(next) {
-        Some(word) if word.starts_with('-') => None,
-        _ => Some(next),
-    }
-}
-
-/// `-c`/`--call` embeds a whole shell command string rather than naming the
-/// program positionally — resolving past it would mean guessing at a
-/// program buried inside that string, so it's left unrecognised and
-/// resolution stops at `npx` (#199).
-const NPX_OPTS: OptionTable = OptionTable {
-    flags: &["-y", "--yes", "--no", "-q", "--quiet", "--ignore-existing"],
-    valued: &["-p", "--package", "--shell"],
-    bundles_short_options: false,
-};
-
-const PNPM_OPTS: OptionTable = OptionTable {
-    flags: &[
-        "--silent",
-        "-s",
-        "--stream",
-        "--aggregate-output",
-        "--no-progress",
-    ],
-    // `--package`/`--package=value` is documented in this pre-`dlx`
-    // position (`pnpm --package=x dlx y`), alongside the identical flag
-    // `dlx` itself also accepts (`PNPM_DLX_OPTS`).
-    valued: &["-C", "--dir", "--filter", "--package"],
-    bundles_short_options: false,
-};
-
-const YARN_OPTS: OptionTable = OptionTable {
-    flags: &["--silent", "-s", "--no-progress", "--non-interactive"],
-    valued: &["--cwd"],
-    bundles_short_options: false,
-};
-
-const PNPM_DLX_OPTS: OptionTable = OptionTable {
-    flags: &["-s", "--silent"],
-    valued: &["--package"],
-    bundles_short_options: false,
-};
-
-const YARN_DLX_OPTS: OptionTable = OptionTable {
-    flags: &["-q", "--quiet"],
-    valued: &["-p", "--package"],
-    bundles_short_options: false,
-};
-
-const BUN_X_OPTS: OptionTable = OptionTable {
-    flags: &["--bun", "--no-install", "--verbose", "--silent"],
-    valued: &["-p", "--package"],
-    bundles_short_options: false,
-};
-
-/// A resolver for one wrapper form: given the tokenized command and the
-/// index of the wrapper word itself, the index of the word after it (past
-/// its options and any subcommand it requires), or `None` if this occurrence
-/// isn't a form we resolve through.
-type WrapperResolver = fn(&[&str], usize) -> Option<usize>;
-
-/// One recognised wrapper form: how to walk past it, and whether an
-/// assignment word is a valid follow-on once it's been walked past.
-struct Wrapper {
-    resolve: WrapperResolver,
-    /// `true` only for wrappers that themselves interpret a following
-    /// `FOO=bar` as an environment assignment for the command they launch
-    /// (`env`, `sudo`), or a shell keyword that restarts the assignment-prefix
-    /// grammar for a brand new simple command (`time`). Every other wrapper
-    /// here is a plain executable that execs its next argument as the
-    /// program outright — an assignment-shaped one names a program literally
-    /// called `FOO=1`, not an env var (#199).
-    accepts_assignment: bool,
-}
-
-fn wrapper_resolver(name: &str) -> Option<Wrapper> {
-    let (resolve, accepts_assignment): (WrapperResolver, bool) = match name {
-        "env" => (|words, i| ENV_OPTS.consume(words, i + 1), true),
-        "sudo" => (|words, i| SUDO_OPTS.consume(words, i + 1), true),
-        "command" => (|words, i| COMMAND_BUILTIN_OPTS.consume(words, i + 1), false),
-        "nohup" => (|words, i| NO_OPTIONS.consume(words, i + 1), false),
-        "time" => (resolve_time, true),
-        "npx" => (|words, i| NPX_OPTS.consume(words, i + 1), false),
-        "pnpm" => (
-            |words, i| resolve_dlx(&PNPM_OPTS, &PNPM_DLX_OPTS, words, i),
-            false,
-        ),
-        "yarn" => (
-            |words, i| resolve_dlx(&YARN_OPTS, &YARN_DLX_OPTS, words, i),
-            false,
-        ),
-        "bun" => (resolve_bun, false),
-        "bunx" => (|words, i| BUN_X_OPTS.consume(words, i + 1), false),
-        "uvx" => (|_words, i| Some(i + 1), false),
-        _ => return None,
-    };
-    Some(Wrapper {
-        resolve,
-        accepts_assignment,
-    })
-}
-
-/// `pnpm`/`yarn` only look through to the package behind an explicit `dlx`
-/// — without it, the next word is a `package.json` script name, not a
-/// package to run (#199: `pnpm claude` is not `pnpm dlx claude`). `dlx`
-/// itself takes launcher-specific options too, consumed before the executable.
-fn resolve_dlx(
-    opts: &OptionTable,
-    dlx_opts: &OptionTable,
-    words: &[&str],
-    i: usize,
-) -> Option<usize> {
-    let j = opts.consume(words, i + 1)?;
-    if words.get(j) != Some(&"dlx") {
-        return None;
-    }
-    dlx_opts.consume(words, j + 1)
-}
-
-/// `bun x <pkg>` is bun's `dlx`/`npx` equivalent; `bun run <script>` is not
-/// (the same package-script ambiguity as bare `pnpm`/`yarn`), so only an `x`
-/// subcommand is looked through. `--bun` (`BUN_X_OPTS`) may follow it before
-/// the executable.
-fn resolve_bun(words: &[&str], i: usize) -> Option<usize> {
-    if words.get(i + 1) != Some(&"x") {
-        return None;
-    }
-    BUN_X_OPTS.consume(words, i + 2)
-}
-
-/// `FOO=bar`, the shell's own prefix for one command's environment —
-/// recognised only when the `=` came from plain, unquoted/unescaped source
-/// text (#199): `"FOO=1"` and `FOO\=1` name a program called `FOO=1`, not
-/// an assignment.
-fn is_env_assignment(word: &Word) -> bool {
-    let Some(eq) = word.plain_eq else {
-        return false;
-    };
-    let name = &word.text[..eq];
-    let mut chars = name.chars();
+/// `FOO=bar`, the shell's own prefix for one command's environment.
+fn is_env_assignment(word: &str) -> bool {
+    let mut chars = word.chars();
     match chars.next() {
         Some(c) if c.is_ascii_alphabetic() || c == '_' => {}
         _ => return false,
     }
-    chars.all(|c| c.is_ascii_alphanumeric() || c == '_')
+    let rest: String = chars.collect();
+    match rest.split_once('=') {
+        Some((name, _)) => name.chars().all(|c| c.is_ascii_alphanumeric() || c == '_'),
+        None => false,
+    }
 }
 
 fn basename(word: &str) -> &str {
@@ -726,7 +268,6 @@ mod tests {
 
     fn session(cwd: &str) -> Session {
         Session {
-            view: Default::default(),
             id: Uuid::from_u128(1),
             cwd: PathBuf::from(cwd),
             command: "bash".into(),
@@ -743,9 +284,7 @@ mod tests {
             current_cwd: None,
             blocked_work: None,
             last_focused_at: None,
-            acp_session_id: None,
-            auto_approve: false,
-            queued_prompts: Vec::new(),
+            agent_session_id: None,
         }
     }
 
@@ -957,132 +496,38 @@ mod tests {
             "claude"
         );
         assert_eq!(command_program("  zsh   -l  "), "zsh");
-    }
-
-    /// The #199 resolver contract: every case in the shared parity fixture,
-    /// asserted identically here and by `web/src/toolIcon.test.ts`, so a
-    /// resolver regression in either language fails its own suite.
-    #[test]
-    fn resolves_the_shared_command_resolution_fixture() {
-        #[derive(serde::Deserialize)]
-        struct Case {
-            command: String,
-            program: String,
-            tool: Option<String>,
-        }
-        #[derive(serde::Deserialize)]
-        struct Fixture {
-            cases: Vec<Case>,
-        }
-        let raw = include_str!("../../../fixtures/command-resolution.json");
-        let fixture: Fixture = serde_json::from_str(raw).expect("valid fixture JSON");
-        assert!(!fixture.cases.is_empty());
-        for case in &fixture.cases {
-            assert_eq!(
-                command_program(&case.command),
-                case.program,
-                "program for {:?}",
-                case.command
-            );
-            assert_eq!(
-                command_tool(&case.command),
-                case.tool.as_deref(),
-                "tool for {:?}",
-                case.command
-            );
-        }
-    }
-
-    fn word(text: &str) -> Word {
-        Word {
-            text: text.into(),
-            plain_eq: None,
-        }
-    }
-
-    /// Shell-aware tokenization (#199): quoting/escaping is honoured, never
-    /// evaluated — no `$var`/`` `cmd` ``/`$(cmd)` expansion is attempted.
-    #[test]
-    fn tokenize_handles_quotes_and_escapes_without_expanding_anything() {
-        assert_eq!(
-            tokenize("claude --resume"),
-            Some(vec![word("claude"), word("--resume")])
-        );
-        assert_eq!(
-            tokenize("\"/opt/my agent/claude\" --resume"),
-            Some(vec![word("/opt/my agent/claude"), word("--resume")])
-        );
-        assert_eq!(
-            tokenize("FOO=\"bar baz\" claude"),
-            Some(vec![
-                Word {
-                    text: "FOO=bar baz".into(),
-                    plain_eq: Some(3),
-                },
-                word("claude"),
-            ])
-        );
-        assert_eq!(
-            tokenize("claude --name=$HOME"),
-            Some(vec![
-                word("claude"),
-                Word {
-                    text: "--name=$HOME".into(),
-                    plain_eq: Some(6),
-                },
-            ]),
-            "a bare $ is kept literal, never expanded"
-        );
-    }
-
-    /// Real shell grammar this resolver doesn't attempt — pipelines, list
-    /// operators, subshells/substitution, an unescaped newline, an
-    /// unterminated quote — is rejected outright rather than guessed
-    /// through (#199).
-    #[test]
-    fn tokenize_rejects_ambiguous_shell_grammar() {
-        for command in [
-            "claude | tee log.txt",
-            "claude; echo done",
-            "claude && echo done",
-            "echo hi $(claude)",
-            "claude \"unterminated",
-            "claude 'unterminated",
-            "claude \\",
-            "claude\nclaude-code", // an unescaped newline separates commands, like `;`
-        ] {
-            assert_eq!(tokenize(command), None, "{command:?}");
-        }
-    }
-
-    /// A backslash immediately before a newline is a line continuation:
-    /// removed entirely, joining what it split rather than embedding a
-    /// literal newline or ending the command (#199).
-    #[test]
-    fn tokenize_treats_backslash_newline_as_a_continuation() {
-        assert_eq!(
-            tokenize("clau\\\nde --resume"),
-            Some(vec![word("claude"), word("--resume")])
-        );
-    }
-
-    /// Only a plain, unquoted/unescaped `=` marks an assignment boundary —
-    /// quoting or escaping the `=` itself disqualifies the word, even
-    /// though the dequoted text looks identical (#199).
-    #[test]
-    fn tokenize_only_marks_plain_unquoted_equals_signs_as_assignments() {
-        assert_eq!(tokenize("FOO=1 claude").unwrap()[0].plain_eq, Some(3));
-        assert_eq!(tokenize("\"FOO=1\" claude").unwrap()[0].plain_eq, None);
-        assert_eq!(tokenize("FOO\\=1 claude").unwrap()[0].plain_eq, None);
+        assert_eq!(command_program("hx src/main.rs"), "hx");
     }
 
     #[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"));
+    fn command_program_looks_through_paths_env_and_wrappers() {
+        assert_eq!(command_program("/usr/local/bin/claude -p hi"), "claude");
+        assert_eq!(command_program("FOO=1 BAR=2 claude"), "claude");
+        assert_eq!(command_program("npx opencode"), "opencode");
+        assert_eq!(command_program("pnpm dlx opencode run"), "opencode");
+    }
+
+    #[test]
+    fn command_program_keeps_a_line_that_is_only_wrappers() {
+        assert_eq!(command_program("sudo"), "sudo");
+        assert_eq!(command_program(""), "");
+    }
+
+    /// The command bar's `tool` field (docs/COMMAND-BAR.md) names the same
+    /// tools the web's `splitCommand().tool` does.
+    #[test]
+    fn command_tool_names_the_mark_the_card_shows() {
+        assert_eq!(command_tool("claude --resume"), Some("claude"));
+        assert_eq!(command_tool("npx opencode"), Some("opencode"));
+        assert_eq!(command_tool("/bin/zsh -l"), Some("shell"));
+        assert_eq!(command_tool("CLAUDE"), Some("claude"));
+    }
+
+    /// Narrow on purpose: an unrecognised program has no mark, so the
+    /// candidate has no `tool` field to match rather than a wrong one.
+    #[test]
+    fn command_tool_is_absent_for_an_unrecognised_program() {
+        assert_eq!(command_tool("hx src/main.rs"), None);
+        assert_eq!(command_tool(""), None);
     }
 }

crates/maestro-protocol/src/lib.rs

@@ -116,43 +116,13 @@ pub struct Session {
     /// sorts a never-focused session after every session that has one.
     #[serde(default)]
     pub last_focused_at: Option<DateTime<Utc>>,
-    /// Whether this session's process is a plain terminal (PTY bytes through
-    /// tmux) or a structured agent driven over ACP rows (#133). Fixed at
-    /// spawn time and never changes for the life of the session. Defaults to
-    /// `Terminal` on the wire so every existing client and payload from a
-    /// daemon that predates the field keeps working untouched.
-    #[serde(default)]
-    pub view: SessionView,
-    /// The ACP session id the selected provider adapter handed back from
-    /// `session/new` (#134). Only a [`SessionView::Structured`] session has
-    /// one, and only once its handshake succeeded; a later respawn passes it
-    /// to `session/load` so the conversation continues (#135). Distinct from
-    /// the hook-reported Claude Code conversation id (#161): that one is what
-    /// `claude --resume` takes, this one is what the ACP adapter takes, and
-    /// the two are minted by different processes with different lifetimes.
+    /// The conversation id the agent running in this session reported for
+    /// itself (#161), parsed from a hook's `session_id` field. Written once,
+    /// from the first activity report that carries one, and left alone after
+    /// — an agent's own session id does not change mid-session. `None` for
+    /// sessions that never run an agent (plain shells) or predate the field.
     #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub acp_session_id: Option<String>,
-    /// When `true` the daemon auto-approves every ACP permission request for
-    /// this session instead of surfacing them to the client. Set at spawn time
-    /// from the preset or the `CreateSessionRequest`; persisted so it survives
-    /// a daemon restart.
-    #[serde(default)]
-    pub auto_approve: bool,
-    /// Prompts queued on the daemon while a turn was in flight or the adapter
-    /// was still booting. Persisted so the queue survives a daemon restart.
-    #[serde(default, skip_serializing_if = "Vec::is_empty")]
-    pub queued_prompts: Vec<String>,
-}
-
-/// A session's process shape (#133): a plain terminal, or a structured agent
-/// driven over ACP rows. Chosen at spawn and immutable for the session's
-/// life. `Terminal` is the default — every sidecar and `CreateSessionRequest`
-/// written before this field existed meant a terminal session.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
-pub enum SessionView {
-    #[default]
-    Terminal,
-    Structured,
+    pub agent_session_id: Option<String>,
 }
 
 /// Default for [`Session::last_activity_at`] when an older payload omits it.
@@ -160,15 +130,43 @@ fn epoch() -> DateTime<Utc> {
     DateTime::from_timestamp(0, 0).expect("unix epoch is a valid timestamp")
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+/// Lifecycle of a session as the daemon knows it.
+///
+/// Deserializes leniently, like [`ActivityState`] (#162): an unknown spelling
+/// from a newer daemon reads as [`SessionStatus::Dead`] instead of failing the
+/// whole `Session`. `Dead` is the safe degrade — an unrecognised session is
+/// one this client must not treat as having a live pane to type into.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
 pub enum SessionStatus {
     Running,
     Dead,
+    /// Known from its sidecar, with no tmux session behind it (#162). The
+    /// daemon registers these at recovery time for every sidecar tmux had
+    /// nothing to adopt — after a host reboot, that is every session there
+    /// was. There is no pane and no PTY bridge: a dormant session is a record
+    /// of what was running, listed so the operator still has it, and the only
+    /// thing that can be done to it is dismissing it.
+    Dormant,
 }
 
-/// Session activity, orthogonal to [`SessionStatus`] (NAP-340). Terminal
-/// sessions use pane/process inference and agent reports; structured sessions
-/// use their ACP turn lifecycle (docs/SIDEBAR.md).
+impl<'de> Deserialize<'de> for SessionStatus {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let s = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "Running" => Self::Running,
+            "Dormant" => Self::Dormant,
+            // Known or not, any other spelling degrades to the inert variant.
+            _ => Self::Dead,
+        })
+    }
+}
+
+/// Inferred session activity, orthogonal to [`SessionStatus`] (NAP-340). The
+/// daemon derives this from tmux pane state, PTY quiescence, and `/proc`
+/// inspection — never by parsing the terminal byte stream.
 ///
 /// Deserializes leniently (#110, SIDEBAR.md Precedence): an unknown variant
 /// from a newer daemon becomes [`ActivityState::Idle`] instead of failing the
@@ -176,19 +174,16 @@ pub enum SessionStatus {
 /// forgiven.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Default)]
 pub enum ActivityState {
-    /// Producing output, the foreground process is busy, or an ACP turn is active.
+    /// Producing output, or the foreground process is busy.
     Active,
     /// Foreground process alive but quiescent. The forward-compatible default.
     #[default]
     Idle,
-    /// Blocked on terminal input or waiting for an ACP approval.
+    /// Blocked on a `read()` from the pty — waiting on the user.
     AwaitingInput,
-    /// An agent reported a failure, or a structured session/turn failed.
+    /// The agent running in the session reported a failure (#102). Never
+    /// inferred by the daemon; only set when an agent reports it (#105).
     Error,
-    /// The ACP adapter is booting; the session is registered but cannot accept
-    /// prompts yet. Older clients that do not know this variant degrade it to
-    /// `Idle` via the lenient deserializer — acceptable.
-    Starting,
 }
 
 impl<'de> Deserialize<'de> for ActivityState {
@@ -201,7 +196,6 @@ impl<'de> Deserialize<'de> for ActivityState {
             "Active" => Self::Active,
             "AwaitingInput" => Self::AwaitingInput,
             "Error" => Self::Error,
-            "Starting" => Self::Starting,
             // Known or not, any other spelling degrades to the neutral default
             _ => Self::Idle,
         })
@@ -225,6 +219,11 @@ pub struct ReportActivityRequest {
     /// The daemon caps its length server-side.
     #[serde(default)]
     pub detail: Option<String>,
+    /// The agent's own conversation id (#161), forwarded from the hook
+    /// payload's `session_id` field. `None` for hook events that don't carry
+    /// one, or hooks predating this field.
+    #[serde(default)]
+    pub session_id: Option<String>,
 }
 
 /// Reject an unknown [`ActivityState`] spelling instead of degrading it to
@@ -240,10 +239,9 @@ where
         "Idle" => Ok(ActivityState::Idle),
         "AwaitingInput" => Ok(ActivityState::AwaitingInput),
         "Error" => Ok(ActivityState::Error),
-        "Starting" => Ok(ActivityState::Starting),
         other => Err(D::Error::unknown_variant(
             other,
-            &["Active", "Idle", "AwaitingInput", "Error", "Starting"],
+            &["Active", "Idle", "AwaitingInput", "Error"],
         )),
     }
 }
@@ -394,15 +392,6 @@ pub struct CreateSessionRequest {
     pub metadata: HashMap<String, Value>,
     #[serde(default)]
     pub worktree: Option<WorktreeSpec>,
-    /// The process shape to spawn (#133). Defaulted so every existing client
-    /// and `curl` against the API keeps requesting a `Terminal` session
-    /// untouched.
-    #[serde(default)]
-    pub view: SessionView,
-    /// When `true`, the daemon auto-approves every ACP permission request
-    /// for this structured session.
-    #[serde(default)]
-    pub auto_approve: bool,
 }
 
 /// Result of `GET /api/dirs`: the immediate subdirectories of one directory.
@@ -540,13 +529,34 @@ impl ApiError {
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub struct SpawnPreset {
     pub id: String,
+    #[serde(default)]
     pub label: String,
     pub command: String,
-    /// When `true`, the daemon auto-approves every ACP permission request
-    /// for structured sessions spawned from this preset instead of surfacing
-    /// them to the client.
-    #[serde(default)]
-    pub auto_approve: bool,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub resume_command: Option<String>,
+}
+
+/// Placeholder a preset's `resume_command` may carry for the agent's own
+/// conversation id (#165), substituted from [`Session::agent_session_id`].
+pub const AGENT_SESSION_PLACEHOLDER: &str = "{agent_session}";
+
+impl SpawnPreset {
+    /// The command that resumes a session spawned from this preset, with
+    /// [`AGENT_SESSION_PLACEHOLDER`] filled in from `agent_session`.
+    ///
+    /// `None` when the preset has no `resume_command` — a plain shell has
+    /// nothing to resume — and also when the template asks for an agent
+    /// session id the session never reported: `claude --resume` with an empty
+    /// id resumes nothing, so the caller is better off respawning the original
+    /// command than running a broken one.
+    pub fn resume_command_for(&self, agent_session: Option<&str>) -> Option<String> {
+        let template = self.resume_command.as_deref()?;
+        if !template.contains(AGENT_SESSION_PLACEHOLDER) {
+            return Some(template.to_string());
+        }
+        let id = agent_session.filter(|s| !s.is_empty())?;
+        Some(template.replace(AGENT_SESSION_PLACEHOLDER, id))
+    }
 }
 
 /// Build provenance of the running daemon: the commit it was compiled
@@ -779,154 +789,6 @@ pub enum CatalogEvent {
     },
 }
 
-// ---------------------------------------------------------------------------
-// Structured-session projections
-// ---------------------------------------------------------------------------
-
-/// One client-neutral item in a structured session transcript.
-///
-/// `data` preserves the ACP payload without committing clients to an ACP
-/// dependency. Rendering choices, including markdown and tool-card treatment,
-/// stay with the client.
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-pub struct TranscriptRow {
-    /// Stable within one session, so later deltas can address this row.
-    pub id: String,
-    pub kind: TranscriptRowKind,
-    pub data: Value,
-}
-
-/// The semantic shape of a [`TranscriptRow`].
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "snake_case")]
-pub enum TranscriptRowKind {
-    User,
-    AgentText,
-    AgentThought,
-    ToolCall,
-    ToolDiff,
-    Approval,
-    Plan,
-    Notice,
-}
-
-/// A complete transcript at a durable event-log position.
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-pub struct TranscriptSnapshot {
-    pub cursor: u64,
-    #[serde(default)]
-    pub rows: Vec<TranscriptRow>,
-}
-
-/// One durable, client-neutral replay step from a structured session.
-///
-/// Results are ordered by increasing `cursor`. `since` returns the first
-/// matching steps; `before` returns the final matching steps, still increasing.
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-pub struct StructuredReplayEvent {
-    /// Durable ACP-log position represented by this projected step.
-    pub cursor: u64,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub transcript: Option<TranscriptDelta>,
-    pub state: ReducedState,
-}
-
-/// A change to a transcript row.
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-#[serde(tag = "type", rename_all = "snake_case")]
-pub enum TranscriptDelta {
-    Append { row: TranscriptRow },
-    Patch { row: TranscriptRow },
-    Remove { id: String },
-}
-
-/// Per-turn indicators derived from the ACP stream.
-#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
-pub struct TurnState {
-    #[serde(default)]
-    pub responding: bool,
-    #[serde(default)]
-    pub thinking: bool,
-    #[serde(default)]
-    pub active_tool_calls: Vec<String>,
-    /// Wall-clock start of the active prompt. This lets reconnecting clients
-    /// keep one continuous elapsed-time display instead of restarting at zero.
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub started_at: Option<DateTime<Utc>>,
-    /// Context-window usage when the active prompt began. ACP exposes context
-    /// occupancy, not provider billing-token accounting, so clients must label
-    /// deltas as context tokens rather than tokens billed.
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub started_context_tokens: Option<u64>,
-}
-
-/// A whole-session view derived from ACP notifications.
-///
-/// Values whose shape ACP owns are carried as JSON so this wire protocol stays
-/// forward-compatible when ACP adds fields or variants.
-#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
-pub struct ReducedState {
-    #[serde(default)]
-    pub turn: TurnState,
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub pending_approval: Option<Value>,
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub plan: Option<Value>,
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub usage: Option<Value>,
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub context: Option<Value>,
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub model: Option<String>,
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub mode: Option<String>,
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub config_options: Option<Value>,
-    /// Prompts queued on the daemon while a turn is in flight. Drained as
-    /// a single concatenated prompt when the current turn completes.
-    #[serde(default, skip_serializing_if = "Vec::is_empty")]
-    pub queued_prompts: Vec<String>,
-}
-
-/// Server messages sent over a structured-session WebSocket.
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-#[serde(tag = "type", rename_all = "snake_case")]
-pub enum StructuredEvent {
-    TranscriptSnapshot {
-        snapshot: TranscriptSnapshot,
-    },
-    ReducedState {
-        state: ReducedState,
-    },
-    ProjectionUpdate {
-        #[serde(skip_serializing_if = "Option::is_none")]
-        transcript: Option<TranscriptDelta>,
-        state: ReducedState,
-    },
-}
-
-/// HTTP body for `POST /api/sessions/:id/structured/prompt`.
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-pub struct StructuredPromptRequest {
-    pub prompt: String,
-}
-
-/// HTTP body for `POST /api/sessions/:id/structured/config`.
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-pub struct StructuredConfigRequest {
-    pub config_id: String,
-    pub value: Value,
-}
-
-/// Operator decision for a pending ACP permission request.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "snake_case")]
-pub enum StructuredApprovalDecision {
-    AllowOnce,
-    AllowForSession,
-    Deny,
-}
-
 // ---------------------------------------------------------------------------
 // Client ↔ Daemon control messages (text frames on the attach WS)
 // ---------------------------------------------------------------------------
@@ -946,6 +808,47 @@ pub enum ClientControl {
 mod tests {
     use super::*;
 
+    fn preset(resume: Option<&str>) -> SpawnPreset {
+        SpawnPreset {
+            id: "claude".into(),
+            label: "Claude".into(),
+            command: "claude".into(),
+            resume_command: resume.map(str::to_string),
+        }
+    }
+
+    #[test]
+    fn resume_command_substitutes_the_agent_session() {
+        let p = preset(Some("claude --resume {agent_session}"));
+        assert_eq!(
+            p.resume_command_for(Some("abc-123")).as_deref(),
+            Some("claude --resume abc-123")
+        );
+    }
+
+    #[test]
+    fn resume_command_without_a_placeholder_ignores_the_agent_session() {
+        let p = preset(Some("opencode --continue"));
+        assert_eq!(
+            p.resume_command_for(None).as_deref(),
+            Some("opencode --continue")
+        );
+    }
+
+    /// A template that wants an id the session never reported would run
+    /// `claude --resume` against nothing; the caller respawns instead.
+    #[test]
+    fn resume_command_is_none_without_the_id_it_asks_for() {
+        let p = preset(Some("claude --resume {agent_session}"));
+        assert!(p.resume_command_for(None).is_none());
+        assert!(p.resume_command_for(Some("")).is_none());
+    }
+
+    #[test]
+    fn a_preset_without_a_resume_command_has_none() {
+        assert!(preset(None).resume_command_for(Some("abc")).is_none());
+    }
+
     #[test]
     fn version_compatibility_is_major_only() {
         assert!(is_compatible(PROTOCOL_VERSION));
@@ -1066,10 +969,7 @@ mod tests {
             current_cwd: Some(PathBuf::from("/home/naps62/projects/maestro/crates")),
             blocked_work: None,
             last_focused_at: None,
-            view: SessionView::Terminal,
-            acp_session_id: None,
-            auto_approve: false,
-            queued_prompts: Vec::new(),
+            agent_session_id: None,
         }
     }
 
@@ -1239,6 +1139,7 @@ mod tests {
         let full = ReportActivityRequest {
             state: ActivityState::AwaitingInput,
             detail: Some("waiting on permission".into()),
+            session_id: Some("conv-abc123".into()),
         };
         assert_eq!(full, round_trip(&full));
 
@@ -1267,6 +1168,33 @@ mod tests {
             serde_json::to_value(SessionStatus::Dead).unwrap(),
             serde_json::json!("Dead")
         );
+        assert_eq!(
+            serde_json::to_value(SessionStatus::Dormant).unwrap(),
+            serde_json::json!("Dormant")
+        );
+    }
+
+    // #162: a session with no tmux behind it still rides the wire whole.
+    #[test]
+    fn dormant_session_round_trips() {
+        let mut s = sample_session();
+        s.status = SessionStatus::Dormant;
+        assert_eq!(s, round_trip(&s));
+    }
+
+    // #162: a `SessionStatus` this client does not know must degrade to the
+    // inert variant, not fail the whole `Session` the way a derived
+    // `Deserialize` would.
+    #[test]
+    fn unknown_session_status_degrades_to_dead() {
+        assert_eq!(
+            serde_json::from_value::<SessionStatus>(serde_json::json!("Hibernating")).unwrap(),
+            SessionStatus::Dead
+        );
+        let mut value = serde_json::to_value(sample_session()).unwrap();
+        value["status"] = serde_json::json!("Hibernating");
+        let s: Session = serde_json::from_value(value).expect("session survives unknown status");
+        assert_eq!(s.status, SessionStatus::Dead);
     }
 
     #[test]
@@ -1281,8 +1209,6 @@ mod tests {
                 branch: "feat/foo".into(),
                 create_branch: true,
             }),
-            view: SessionView::Terminal,
-            auto_approve: false,
         };
         assert_eq!(req, round_trip(&req));
     }
@@ -1297,74 +1223,6 @@ mod tests {
         assert!(req.worktree.is_none());
         assert!(req.env.is_empty());
         assert!(req.metadata.is_empty());
-        assert_eq!(req.view, SessionView::Terminal);
-    }
-
-    #[test]
-    fn session_view_defaults_to_terminal_on_legacy_payload() {
-        // A pre-#133 daemon or client omits `view`; it must deserialize to
-        // `Terminal` rather than failing, and `Structured` round-trips.
-        let json = serde_json::json!({
-            "id": Uuid::from_u128(1),
-            "cwd": "/tmp",
-            "command": "bash",
-            "status": "Running",
-            "created_at": "2026-05-24T12:00:00Z"
-        });
-        let s: Session = serde_json::from_value(json).unwrap();
-        assert_eq!(s.view, SessionView::Terminal);
-
-        let mut structured = sample_session();
-        structured.view = SessionView::Structured;
-        assert_eq!(structured, round_trip(&structured));
-    }
-
-    #[test]
-    fn structured_projection_types_round_trip_and_default() {
-        let row = TranscriptRow {
-            id: "tool:read-1".into(),
-            kind: TranscriptRowKind::ToolCall,
-            data: serde_json::json!({"name": "vendor.read", "title": "Read"}),
-        };
-        let snapshot = TranscriptSnapshot {
-            cursor: 7,
-            rows: vec![row.clone()],
-        };
-        assert_eq!(snapshot, round_trip(&snapshot));
-        assert_eq!(
-            TranscriptDelta::Patch { row: row.clone() },
-            round_trip(&TranscriptDelta::Patch { row })
-        );
-
-        let state: ReducedState = serde_json::from_value(serde_json::json!({})).unwrap();
-        assert_eq!(state, ReducedState::default());
-        assert_eq!(
-            serde_json::to_value(TranscriptRowKind::AgentThought).unwrap(),
-            serde_json::json!("agent_thought")
-        );
-    }
-
-    #[test]
-    fn acp_session_id_defaults_to_none_and_round_trips() {
-        // A payload from before #134 carries no `acp_session_id`; it must
-        // read as `None`, stay off the wire while unset, and round-trip
-        // once the adapter has handed one back.
-        let json = serde_json::json!({
-            "id": Uuid::from_u128(1),
-            "cwd": "/tmp",
-            "command": "bash",
-            "status": "Running",
-            "created_at": "2026-05-24T12:00:00Z"
-        });
-        let s: Session = serde_json::from_value(json).unwrap();
-        assert_eq!(s.acp_session_id, None);
-        let serialized = serde_json::to_value(&s).unwrap();
-        assert!(serialized.get("acp_session_id").is_none());
-
-        let mut structured = sample_session();
-        structured.view = SessionView::Structured;
-        structured.acp_session_id = Some("sess_01HZX".into());
-        assert_eq!(structured, round_trip(&structured));
     }
 
     /// A client that predates the new/existing discriminator sends no

crates/maestro-protocol/src/routes.rs

@@ -66,46 +66,17 @@ pub fn session_focus(id: Uuid) -> String {
     format!("{SESSIONS}/{id}/focus")
 }
 
+/// `POST /api/sessions/:id/resume` (#166): respawn a dormant session under its
+/// own id, keeping its sidecar, name, worktree and `created_at`.
+pub fn session_resume(id: Uuid) -> String {
+    format!("{SESSIONS}/{id}/resume")
+}
+
 /// `WS /api/attach/:id` — raw PTY bytes.
 pub fn attach(id: Uuid) -> String {
     format!("{API_PREFIX}/attach/{id}")
 }
 
-/// `WS /api/structured/:id` — transcript/state snapshots and live deltas.
-pub fn structured(id: Uuid) -> String {
-    format!("{API_PREFIX}/structured/{id}")
-}
-
-/// `GET /api/sessions/:id/structured/replay` — cursor-bounded ACP history.
-pub fn structured_replay(id: Uuid) -> String {
-    format!("{SESSIONS}/{id}/structured/replay")
-}
-
-/// `POST /api/sessions/:id/structured/prompt` — send an ACP prompt.
-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")
-}
-
-/// `POST /api/sessions/:id/structured/config` — change an ACP session option.
-pub fn structured_config(id: Uuid) -> String {
-    format!("{SESSIONS}/{id}/structured/config")
-}
-
-/// `POST /api/sessions/:id/structured/approvals/:nonce` — answer ACP permission.
-pub fn structured_approval(id: Uuid, nonce: &str) -> String {
-    format!("{SESSIONS}/{id}/structured/approvals/{nonce}")
-}
-
 /// Axum-style patterns for the two parameterised routes, so the server
 /// registers the same paths [`session`] and [`attach`] build.
 pub mod patterns {
@@ -114,14 +85,8 @@ pub mod patterns {
     pub const SESSION_INPUT: &str = "/api/sessions/:id/input";
     pub const SESSION_PROMPT: &str = "/api/sessions/:id/prompt";
     pub const SESSION_FOCUS: &str = "/api/sessions/:id/focus";
+    pub const SESSION_RESUME: &str = "/api/sessions/:id/resume";
     pub const ATTACH: &str = "/api/attach/:id";
-    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";
 }
 
 /// A daemon base URL that could not be turned into a WebSocket base.
@@ -171,11 +136,6 @@ pub fn attach_url(http_base: &str, id: Uuid) -> Result<String, UrlError> {
     Ok(format!("{}{}", ws_base(http_base)?, attach(id)))
 }
 
-/// Full `WS /api/structured/:id` URL for a daemon reachable at `http_base`.
-pub fn structured_url(http_base: &str, id: Uuid) -> Result<String, UrlError> {
-    Ok(format!("{}{}", ws_base(http_base)?, structured(id)))
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -225,10 +185,6 @@ mod tests {
             events_url("http://host:7070/").unwrap(),
             "ws://host:7070/api/events"
         );
-        assert_eq!(
-            structured_url("http://host:7070/", id()).unwrap(),
-            "ws://host:7070/api/structured/6f1a7c0e-0f5e-4a2b-9a3d-6b1c2d3e4f50"
-        );
     }
 
     #[test]
@@ -253,26 +209,14 @@ mod tests {
             session_focus(id()),
             "/api/sessions/6f1a7c0e-0f5e-4a2b-9a3d-6b1c2d3e4f50/focus"
         );
+        assert_eq!(
+            session_resume(id()),
+            "/api/sessions/6f1a7c0e-0f5e-4a2b-9a3d-6b1c2d3e4f50/resume"
+        );
         assert_eq!(
             attach(id()),
             "/api/attach/6f1a7c0e-0f5e-4a2b-9a3d-6b1c2d3e4f50"
         );
-        assert_eq!(
-            structured(id()),
-            "/api/structured/6f1a7c0e-0f5e-4a2b-9a3d-6b1c2d3e4f50"
-        );
-        assert_eq!(
-            structured_replay(id()),
-            "/api/sessions/6f1a7c0e-0f5e-4a2b-9a3d-6b1c2d3e4f50/structured/replay"
-        );
-        assert_eq!(
-            structured_prompt(id()),
-            "/api/sessions/6f1a7c0e-0f5e-4a2b-9a3d-6b1c2d3e4f50/structured/prompt"
-        );
-        assert_eq!(
-            structured_cancel(id()),
-            "/api/sessions/6f1a7c0e-0f5e-4a2b-9a3d-6b1c2d3e4f50/structured/cancel"
-        );
         assert_eq!(
             attach_url("https://laptop.lan:7070", id()).unwrap(),
             "wss://laptop.lan:7070/api/attach/6f1a7c0e-0f5e-4a2b-9a3d-6b1c2d3e4f50"
@@ -303,26 +247,14 @@ mod tests {
             patterns::SESSION_FOCUS.trim_end_matches(":id/focus"),
             session(id()).trim_end_matches(&id().to_string())
         );
+        assert_eq!(
+            patterns::SESSION_RESUME.trim_end_matches(":id/resume"),
+            session(id()).trim_end_matches(&id().to_string())
+        );
         assert_eq!(
             patterns::ATTACH.trim_end_matches(":id"),
             attach(id()).trim_end_matches(&id().to_string())
         );
-        assert_eq!(
-            patterns::STRUCTURED.trim_end_matches(":id"),
-            structured(id()).trim_end_matches(&id().to_string())
-        );
-        assert_eq!(
-            patterns::STRUCTURED_REPLAY.trim_end_matches(":id/structured/replay"),
-            session(id()).trim_end_matches(&id().to_string())
-        );
-        assert_eq!(
-            patterns::STRUCTURED_PROMPT.trim_end_matches(":id/structured/prompt"),
-            session(id()).trim_end_matches(&id().to_string())
-        );
-        assert_eq!(
-            patterns::STRUCTURED_CANCEL.trim_end_matches(":id/structured/cancel"),
-            session(id()).trim_end_matches(&id().to_string())
-        );
     }
 
     #[test]
@@ -341,9 +273,5 @@ mod tests {
             assert!(path.starts_with(API_PREFIX), "{path} escapes {API_PREFIX}");
         }
         assert!(attach(id()).starts_with(API_PREFIX));
-        assert!(structured(id()).starts_with(API_PREFIX));
-        assert!(structured_replay(id()).starts_with(API_PREFIX));
-        assert!(structured_prompt(id()).starts_with(API_PREFIX));
-        assert!(structured_cancel(id()).starts_with(API_PREFIX));
     }
 }

crates/maestro-testing/src/lib.rs

@@ -22,8 +22,7 @@ use chrono::Utc;
 use futures_util::{SinkExt, StreamExt};
 use maestro_protocol::{
     routes, ApiError, CatalogEvent, CreateSessionRequest, DaemonClient, DaemonInfo, DirListing,
-    GitRoot, RecentDirs, SendInputRequest, Session, SessionStatus, StructuredPromptRequest,
-    PROTOCOL_VERSION,
+    GitRoot, RecentDirs, SendInputRequest, Session, SessionStatus, PROTOCOL_VERSION,
 };
 use tokio::net::TcpListener;
 use tokio::sync::{broadcast, oneshot};
@@ -32,7 +31,6 @@ use uuid::Uuid;
 /// Build a plausible `Session` for a test to hand to [`MockDaemon::add_session`].
 pub fn session(id: Uuid, cwd: &str, command: &str) -> Session {
     Session {
-        view: Default::default(),
         id,
         cwd: cwd.into(),
         command: command.into(),
@@ -49,9 +47,7 @@ pub fn session(id: Uuid, cwd: &str, command: &str) -> Session {
         current_cwd: None,
         blocked_work: None,
         last_focused_at: None,
-        acp_session_id: None,
-        auto_approve: false,
-        queued_prompts: Vec::new(),
+        agent_session_id: None,
     }
 }
 
@@ -63,8 +59,6 @@ struct Inner {
     forced_error: Option<(u16, ApiError)>,
     /// Everything `POST /api/sessions/:id/input` was asked to type, in order.
     inputs: Vec<(Uuid, SendInputRequest)>,
-    /// Every ACP prompt sent to a structured session, in order.
-    structured_prompts: Vec<(Uuid, StructuredPromptRequest)>,
 }
 
 #[derive(Clone)]
@@ -97,7 +91,6 @@ impl MockDaemon {
             .route(routes::SESSIONS, get(list_sessions).post(create_session))
             .route(routes::patterns::SESSION, delete(kill_session))
             .route(routes::patterns::SESSION_INPUT, post(send_input))
-            .route(routes::patterns::STRUCTURED_PROMPT, post(structured_prompt))
             .route(routes::INFO, get(daemon_info))
             .route(routes::DIRS, get(list_dir))
             .route(routes::RECENT_DIRS, get(recent_dirs))
@@ -184,16 +177,6 @@ impl MockDaemon {
         self.state.inner.lock().expect("poisoned").inputs.clone()
     }
 
-    /// Every ACP prompt this daemon received, oldest first.
-    pub fn structured_prompts(&self) -> Vec<(Uuid, StructuredPromptRequest)> {
-        self.state
-            .inner
-            .lock()
-            .expect("poisoned")
-            .structured_prompts
-            .clone()
-    }
-
     pub fn session_count(&self) -> usize {
         self.state.inner.lock().expect("poisoned").sessions.len()
     }
@@ -282,26 +265,6 @@ async fn send_input(
     StatusCode::NO_CONTENT.into_response()
 }
 
-async fn structured_prompt(
-    State(s): State<AppState>,
-    Path(id): Path<Uuid>,
-    Json(req): Json<StructuredPromptRequest>,
-) -> Response {
-    if let Some(r) = forced(&s) {
-        return r;
-    }
-    let mut guard = s.inner.lock().expect("poisoned");
-    if !guard.sessions.iter().any(|x| x.id == id) {
-        return (
-            StatusCode::NOT_FOUND,
-            Json(ApiError::new("not_found", "no such session on this daemon")),
-        )
-            .into_response();
-    }
-    guard.structured_prompts.push((id, req));
-    StatusCode::NO_CONTENT.into_response()
-}
-
 async fn daemon_info(State(s): State<AppState>) -> Response {
     if let Some(r) = forced(&s) {
         return r;

crates/maestro-tui/Cargo.toml

@@ -21,7 +21,6 @@ thiserror.workspace = true
 tokio = { workspace = true, features = ["sync", "time", "macros", "rt"] }
 tokio-tungstenite.workspace = true
 tracing.workspace = true
-unicode-width.workspace = true
 uuid.workspace = true
 vt100.workspace = true
 

crates/maestro-tui/src/app.rs

@@ -11,17 +11,13 @@
 //! `dispatch` / the overlay routing.
 
 use std::collections::{HashMap, HashSet};
-use std::io::Write;
 use std::path::PathBuf;
 use std::time::Duration;
 
 use chrono::Utc;
 use crossterm::event::{Event as CtEvent, EventStream};
 use futures_util::StreamExt;
-use maestro_protocol::{
-    routes, BranchInfo, CreateSessionRequest, DaemonClient, NameBatch, SessionView,
-    StructuredApprovalDecision,
-};
+use maestro_protocol::{routes, BranchInfo, CreateSessionRequest, DaemonClient, NameBatch};
 use ratatui::Terminal;
 use uuid::Uuid;
 
@@ -42,8 +38,6 @@ use crate::render::{draw, RegionMap, RenderInputs};
 use crate::session_task::{SessionInput, SessionTask};
 use crate::sidebar::Sidebar;
 use crate::state::{AppState, Focus, OverlayKind, SidebarItem};
-use crate::structured_pane::StructuredPane;
-use crate::structured_task::{StructuredHandle, StructuredTask};
 use crate::text_input::TextInput;
 use crate::TuiError;
 
@@ -55,42 +49,11 @@ 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,
     catalog: CatalogStore,
     emulators: SessionEmulators,
-    structured: HashMap<Uuid, StructuredHandle>,
     state: AppState,
     help: HelpOverlay,
     chord: ChordState,
@@ -200,18 +163,6 @@ pub enum Effect {
         id: Uuid,
         bytes: Vec<u8>,
     },
-    StructuredPrompt {
-        id: Uuid,
-        prompt: String,
-    },
-    StructuredCancel {
-        id: Uuid,
-    },
-    StructuredApproval {
-        id: Uuid,
-        nonce: String,
-        decision: StructuredApprovalDecision,
-    },
     /// Fetch presets / projects / names for a freshly opened form (#64).
     LoadDraft,
     /// Fast-forward spawn (#67): resolve every default from the daemon and
@@ -263,7 +214,6 @@ impl App {
             home_dir: std::env::var("HOME").unwrap_or_default(),
             catalog,
             emulators: SessionEmulators::default(),
-            structured: HashMap::new(),
             state: AppState::new(),
             draft: None,
             help,
@@ -371,15 +321,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);
-        }
-
         if let Some(effect) = self.handle_pane_scroll(&key) {
             self.perform(effect.into_iter().collect()).await;
             return Ok(false);
@@ -458,61 +399,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>) {
@@ -533,44 +419,6 @@ impl App {
                         let _ = handle.tx.send(SessionInput::Bytes(bytes)).await;
                     }
                 }
-                Effect::StructuredPrompt { id, prompt } => {
-                    if let Err(error) = self.daemon.send_structured_prompt(id, &prompt).await {
-                        if let Some(handle) = self.structured.get(&id) {
-                            handle
-                                .state
-                                .lock()
-                                .expect("structured state mutex")
-                                .prompt_failed(prompt, error.to_string());
-                        }
-                    }
-                }
-                Effect::StructuredCancel { id } => {
-                    if let Err(error) = self.daemon.cancel_structured_turn(id).await {
-                        if let Some(handle) = self.structured.get(&id) {
-                            handle.state.lock().expect("structured state mutex").error =
-                                Some(error.to_string());
-                        }
-                    }
-                }
-                Effect::StructuredApproval {
-                    id,
-                    nonce,
-                    decision,
-                } => {
-                    if let Err(error) = self
-                        .daemon
-                        .resolve_structured_approval(id, &nonce, decision)
-                        .await
-                    {
-                        if let Some(handle) = self.structured.get(&id) {
-                            handle
-                                .state
-                                .lock()
-                                .expect("structured state mutex")
-                                .approval_failed(&nonce, error.to_string());
-                        }
-                    }
-                }
             }
         }
     }
@@ -715,13 +563,13 @@ impl App {
             Action::OpenCommandBar => effects.extend(self.open_command_bar()),
             // Escape hatch (#156): the literal byte, not the bar.
             Action::SendLiteralCtrlK => {
-                effects.extend(self.forward_literal_to_terminal(&InputKey::ctrl_char('k')));
+                effects.extend(self.forward_to_session(&InputKey::ctrl_char('k')));
             }
             // Escape hatch (#158): the leader's own byte, built from the
             // configured leader rather than a hardcoded key.
             Action::SendLiteralLeader => {
                 let leader = self.cfg.leader.clone();
-                effects.extend(self.forward_literal_to_terminal(&leader));
+                effects.extend(self.forward_to_session(&leader));
             }
             Action::OpenSpawnModal => {
                 self.open_spawn_modal();
@@ -739,7 +587,7 @@ impl App {
                         }
                         // A previewed session is already attached: committing
                         // to it keeps that stream rather than reopening one.
-                        if !self.is_attached(sid) {
+                        if self.emulators.get(sid).is_none() {
                             effects.push(Effect::Attach(sid));
                         }
                     }
@@ -747,9 +595,6 @@ impl App {
                     // preview budget.
                     self.preview_lru.retain(|s| *s != sid);
                     self.state.attach_to_focused(sid);
-                    if self.session_view(sid) == SessionView::Structured {
-                        self.state.mode = Mode::Normal;
-                    }
                 }
             }
             Action::KillHighlighted => {
@@ -818,7 +663,7 @@ impl App {
         self.state.preview = Some(sid);
         // Set outside the input path, so nothing else marks the frame stale.
         self.epoch = self.epoch.wrapping_add(1);
-        let fresh = !self.is_attached(sid);
+        let fresh = self.emulators.get(sid).is_none();
         if fresh {
             self.preview_lru.retain(|s| *s != sid);
             self.preview_lru.push(sid);
@@ -887,27 +732,15 @@ impl App {
 
     /// Open a stream for `sid` if one isn't already running.
     fn attach(&mut self, sid: Uuid) {
-        self.attach_with_view(sid, self.session_view(sid));
-    }
-
-    fn attach_with_view(&mut self, sid: Uuid, view: SessionView) {
-        if self.is_attached(sid) {
+        if self.emulators.get(sid).is_some() {
             return;
         }
-        match view {
-            SessionView::Terminal => match self.daemon.attach_url(sid) {
-                Ok(ws_url) => {
-                    let handle = SessionTask::spawn(ws_url, 24, 80);
-                    self.emulators.insert(sid, handle);
-                }
-                Err(e) => self.state.toast(format!("attach failed: {e}")),
-            },
-            SessionView::Structured => match self.daemon.structured_url(sid) {
-                Ok(ws_url) => {
-                    self.structured.insert(sid, StructuredTask::spawn(ws_url));
-                }
-                Err(e) => self.state.toast(format!("attach failed: {e}")),
-            },
+        match self.daemon.attach_url(sid) {
+            Ok(ws_url) => {
+                let handle = SessionTask::spawn(ws_url, 24, 80);
+                self.emulators.insert(sid, handle);
+            }
+            Err(e) => self.state.toast(format!("attach failed: {e}")),
         }
     }
 
@@ -915,26 +748,9 @@ impl App {
     /// dropping its vt100 parser.
     fn release_session(&mut self, sid: Uuid) {
         self.emulators.remove(sid);
-        if let Some(handle) = self.structured.remove(&sid) {
-            handle.end();
-        }
         self.last_sent_size.remove(&sid);
     }
 
-    fn session_view(&self, sid: Uuid) -> SessionView {
-        self.catalog
-            .snapshot()
-            .sessions
-            .iter()
-            .find(|session| session.id == sid)
-            .map(|session| session.view)
-            .unwrap_or_default()
-    }
-
-    fn is_attached(&self, sid: Uuid) -> bool {
-        self.emulators.get(sid).is_some() || self.structured.contains_key(&sid)
-    }
-
     /// Return the session under the sidebar highlight, falling back to the
     /// first listed session so the user can attach without arrowing first.
     fn pick_sidebar_target(&self) -> Option<Uuid> {
@@ -1001,16 +817,6 @@ impl App {
     /// attached to send it to.
     fn forward_to_session(&mut self, key: &InputKey) -> Option<Effect> {
         let sid = self.state.active_session()?;
-        if let Some(handle) = self.structured.get(&sid) {
-            let mut state = handle.state.lock().expect("structured state mutex");
-            if matches!(key, InputKey::Enter) {
-                return state
-                    .begin_prompt()
-                    .map(|prompt| Effect::StructuredPrompt { id: sid, prompt });
-            }
-            state.edit_composer(key);
-            return None;
-        }
         let handle = self.emulators.get(sid)?;
         let bytes = encode_key(key)?;
         handle
@@ -1021,86 +827,6 @@ impl App {
         Some(Effect::Forward { id: sid, bytes })
     }
 
-    fn forward_literal_to_terminal(&mut self, key: &InputKey) -> Option<Effect> {
-        let sid = self.state.active_session()?;
-        if self.session_view(sid) == SessionView::Structured {
-            return None;
-        }
-        self.forward_to_session(key)
-    }
-
-    fn handle_structured_key(&mut self, key: &InputKey) -> Option<Vec<Effect>> {
-        if self.state.focus != Focus::Pane || self.state.preview.is_some() {
-            return None;
-        }
-        let sid = self.state.active_session()?;
-        let handle = self.structured.get(&sid)?;
-        let mut state = handle.state.lock().expect("structured state mutex");
-        if self.state.mode == Mode::Insert {
-            if matches!(key, InputKey::Esc) && state.turn_active() {
-                return Some(vec![Effect::StructuredCancel { id: sid }]);
-            }
-            return None;
-        }
-        let effects = match key {
-            InputKey::Char {
-                c: 'j',
-                ctrl: false,
-                alt: false,
-                ..
-            }
-            | InputKey::Down => {
-                state.select(1);
-                Vec::new()
-            }
-            InputKey::Char {
-                c: 'k',
-                ctrl: false,
-                alt: false,
-                ..
-            }
-            | InputKey::Up => {
-                state.select(-1);
-                Vec::new()
-            }
-            InputKey::Enter => {
-                state.toggle_selected();
-                Vec::new()
-            }
-            InputKey::Esc => {
-                if state.turn_active() {
-                    vec![Effect::StructuredCancel { id: sid }]
-                } else {
-                    Vec::new()
-                }
-            }
-            InputKey::Char {
-                c: key @ ('a' | 'A' | 'd'),
-                ctrl: false,
-                alt: false,
-                ..
-            } => state
-                .approval_decision(*key)
-                .map(|(nonce, decision)| Effect::StructuredApproval {
-                    id: sid,
-                    nonce,
-                    decision,
-                })
-                .into_iter()
-                .collect(),
-            InputKey::PageUp => {
-                state.scroll_by(self.pane_page_rows() as isize);
-                Vec::new()
-            }
-            InputKey::PageDown => {
-                state.scroll_by(-(self.pane_page_rows() as isize));
-                Vec::new()
-            }
-            _ => return None,
-        };
-        Some(effects)
-    }
-
     fn pane_page_rows(&self) -> usize {
         self.region
             .pane
@@ -1113,14 +839,6 @@ impl App {
         let Some(sid) = self.state.active_session() else {
             return;
         };
-        if let Some(handle) = self.structured.get(&sid) {
-            handle
-                .state
-                .lock()
-                .expect("structured state mutex")
-                .scroll_by(rows);
-            return;
-        }
         let Some(handle) = self.emulators.get(sid) else {
             return;
         };
@@ -1154,14 +872,6 @@ impl App {
             _ => return None,
         };
         let sid = self.state.active_session()?;
-        if let Some(handle) = self.structured.get(&sid) {
-            handle
-                .state
-                .lock()
-                .expect("structured state mutex")
-                .scroll_by(lines);
-            return Some(None);
-        }
         let handle = self.emulators.get(sid)?;
         let pane = self.region.pane?;
         let parser = handle.screen.lock().expect("vt100 parser mutex");
@@ -1584,10 +1294,7 @@ impl App {
                 }
                 self.draft = None;
                 self.state.complete_spawn(sid);
-                if session.view == SessionView::Structured {
-                    self.state.mode = Mode::Normal;
-                }
-                self.attach_with_view(sid, session.view);
+                self.attach(sid);
             }
             Err(e) => {
                 // A failed POST belongs in the form it came from (#64), not a
@@ -1648,11 +1355,6 @@ impl App {
             self.emulators
                 .get(sid)
                 .map(|h| (sid, h.revision(), h.state()))
-                .or_else(|| {
-                    self.structured
-                        .get(&sid)
-                        .map(|h| (sid, h.revision(), h.connection()))
-                })
         });
         FrameKey {
             catalog: self.catalog.version(),
@@ -1714,17 +1416,6 @@ impl App {
                 focused: matches!(self.state.focus, Focus::Pane) && !previewing,
             })
         });
-        let structured_pane = shown_sid.and_then(|sid| {
-            let handle = self.structured.get(&sid)?;
-            let session = snap.sessions.iter().find(|session| session.id == sid)?;
-            Some(StructuredPane {
-                handle: handle.clone(),
-                focused: matches!(self.state.focus, Focus::Pane) && !previewing,
-                mode: self.state.mode,
-                session_status: session.status,
-                activity_detail: session.activity_detail.clone(),
-            })
-        });
         let pane_title = match shown_sid {
             Some(sid) => {
                 let name = snap
@@ -1748,7 +1439,6 @@ impl App {
             home_dir: &self.home_dir,
             pane_title: &pane_title,
             pane: pane.as_ref(),
-            structured_pane: structured_pane.as_ref(),
             state: &self.state,
             draft: self.draft.as_ref(),
             help: &self.help,
@@ -1995,12 +1685,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;
@@ -2198,7 +1882,6 @@ mod tests {
             sessions: ids
                 .iter()
                 .map(|id| Session {
-                    view: Default::default(),
                     id: *id,
                     command: "bash".into(),
                     cwd: std::path::PathBuf::from("/"),
@@ -2215,9 +1898,7 @@ mod tests {
                     current_cwd: None,
                     blocked_work: None,
                     last_focused_at: None,
-                    acp_session_id: None,
-                    auto_approve: false,
-                    queued_prompts: Vec::new(),
+                    agent_session_id: None,
                 })
                 .collect(),
         });
@@ -2383,7 +2064,6 @@ mod tests {
         let mut app = make_app();
         app.catalog.apply_event(CatalogEvent::Snapshot {
             sessions: vec![Session {
-                view: Default::default(),
                 id: sid,
                 command: "bash".into(),
                 cwd: std::path::PathBuf::from("/"),
@@ -2400,9 +2080,7 @@ mod tests {
                 current_cwd: None,
                 blocked_work: None,
                 last_focused_at: None,
-                acp_session_id: None,
-                auto_approve: false,
-                queued_prompts: Vec::new(),
+                agent_session_id: None,
             }],
         });
         app.dispatch(Action::SidebarNext);
@@ -2414,7 +2092,6 @@ mod tests {
         use chrono::Utc;
         use maestro_protocol::{Session, SessionStatus};
         Session {
-            view: Default::default(),
             id: sid,
             command: "bash".into(),
             cwd: cwd.into(),
@@ -2431,9 +2108,7 @@ mod tests {
             current_cwd: None,
             blocked_work: None,
             last_focused_at: None,
-            acp_session_id: None,
-            auto_approve: false,
-            queued_prompts: Vec::new(),
+            agent_session_id: None,
         }
     }
 
@@ -3105,13 +2780,11 @@ mod tests {
         );
         app.dispatch(Action::OpenSpawnModal);
         let req = CreateSessionRequest {
-            view: Default::default(),
             cwd: std::path::PathBuf::from("/srv/work"),
             command: "bash".into(),
             env: Default::default(),
             metadata: Default::default(),
             worktree: None,
-            auto_approve: false,
         };
         app.submit_spawn(req).await;
 
@@ -3128,56 +2801,6 @@ mod tests {
         );
     }
 
-    #[tokio::test]
-    async fn create_response_selects_transport_before_catalog_event() {
-        use axum::routing::post;
-        use axum::Json;
-
-        async fn spawn_session(
-            Json(req): Json<CreateSessionRequest>,
-        ) -> Json<maestro_protocol::Session> {
-            let id = match req.view {
-                SessionView::Terminal => Uuid::from_u128(187),
-                SessionView::Structured => Uuid::from_u128(188),
-            };
-            let mut session = test_session(id, req.cwd.to_str().unwrap());
-            session.view = req.view;
-            session.command = req.command;
-            Json(session)
-        }
-
-        let router =
-            axum::Router::new().route(maestro_protocol::routes::SESSIONS, post(spawn_session));
-        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
-        let base = format!("http://{}", listener.local_addr().unwrap());
-        tokio::spawn(async move { axum::serve(listener, router).await.unwrap() });
-
-        let mut app = make_app_at(&base);
-        let request = |view| CreateSessionRequest {
-            view,
-            cwd: std::path::PathBuf::from("/srv/work"),
-            command: "codex".into(),
-            env: Default::default(),
-            metadata: Default::default(),
-            worktree: None,
-            auto_approve: false,
-        };
-
-        let structured_id = Uuid::from_u128(188);
-        app.state.mode = Mode::Insert;
-        app.submit_spawn(request(SessionView::Structured)).await;
-        assert!(app.catalog.snapshot().sessions.is_empty());
-        assert!(app.structured.contains_key(&structured_id));
-        assert!(app.emulators.get(structured_id).is_none());
-        assert_eq!(app.state.mode, Mode::Normal);
-
-        let terminal_id = Uuid::from_u128(187);
-        app.submit_spawn(request(SessionView::Terminal)).await;
-        assert!(app.catalog.snapshot().sessions.is_empty());
-        assert!(app.emulators.get(terminal_id).is_some());
-        assert!(!app.structured.contains_key(&terminal_id));
-    }
-
     /// The full data load against a live daemon stub: presets replace the
     /// built-ins, projects land sorted, and the first generated name seeds
     /// the field.
@@ -3575,7 +3198,6 @@ mod tests {
         use chrono::Utc;
         use maestro_protocol::{CatalogEvent, Session, SessionStatus};
         let make = |n: u128, name: &str, focused: Option<chrono::DateTime<Utc>>| Session {
-            view: Default::default(),
             id: Uuid::from_u128(n),
             command: "bash".into(),
             cwd: std::path::PathBuf::from("/"),
@@ -3595,9 +3217,7 @@ mod tests {
             current_cwd: None,
             blocked_work: None,
             last_focused_at: focused,
-            acp_session_id: None,
-            auto_approve: false,
-            queued_prompts: Vec::new(),
+            agent_session_id: None,
         };
         let older = Utc::now() - chrono::Duration::seconds(60);
         app.catalog.apply_event(CatalogEvent::Snapshot {
@@ -3859,7 +3479,6 @@ mod tests {
         let sid = Uuid::from_u128(7);
         app.catalog.apply_event(CatalogEvent::Snapshot {
             sessions: vec![Session {
-                view: Default::default(),
                 id: sid,
                 command: "bash".into(),
                 cwd: std::path::PathBuf::from("/"),
@@ -3877,9 +3496,7 @@ mod tests {
                 current_cwd: None,
                 blocked_work: None,
                 last_focused_at: None,
-                acp_session_id: None,
-                auto_approve: false,
-                queued_prompts: Vec::new(),
+                agent_session_id: None,
             }],
         });
         app.dispatch(Action::KillHighlighted);
@@ -3899,7 +3516,6 @@ mod tests {
         };
         app.catalog.apply_event(CatalogEvent::Snapshot {
             sessions: vec![Session {
-                view: Default::default(),
                 id: sid,
                 command: "bash".into(),
                 cwd: std::path::PathBuf::from("/"),
@@ -3916,9 +3532,7 @@ mod tests {
                 current_cwd: None,
                 blocked_work: None,
                 last_focused_at: None,
-                acp_session_id: None,
-                auto_approve: false,
-                queued_prompts: Vec::new(),
+                agent_session_id: None,
             }],
         });
     }
@@ -4076,112 +3690,4 @@ mod tests {
         assert!(app.command_bar.is_none());
         assert!(app.state.overlay().is_none());
     }
-
-    fn structured_app(sid: Uuid) -> App {
-        let mut app = app_with_highlighted_session(sid);
-        let mut session = app.catalog.snapshot().sessions[0].clone();
-        session.view = SessionView::Structured;
-        app.catalog
-            .apply_event(maestro_protocol::CatalogEvent::SessionUpdated { session });
-        app.structured.insert(
-            sid,
-            StructuredHandle::test_handle(crate::structured_task::StructuredState::default()),
-        );
-        app.state.attach_to_focused(sid);
-        app
-    }
-
-    #[tokio::test]
-    async fn session_view_selects_the_structured_connection_and_cleanup_stops_it() {
-        let sid = Uuid::from_u128(141);
-        let mut app = app_with_highlighted_session(sid);
-        let mut session = app.catalog.snapshot().sessions[0].clone();
-        session.view = SessionView::Structured;
-        app.catalog
-            .apply_event(maestro_protocol::CatalogEvent::SessionUpdated { session });
-
-        app.attach(sid);
-        assert!(app.structured.contains_key(&sid));
-        assert!(app.emulators.get(sid).is_none());
-        let handle = app.structured.get(&sid).unwrap().clone();
-        app.release_session(sid);
-        assert_eq!(
-            handle.connection(),
-            crate::session_task::SessionState::Ended
-        );
-    }
-
-    #[test]
-    fn structured_normal_mode_routes_navigation_expansion_and_approval_by_row() {
-        use maestro_protocol::{ReducedState, TranscriptRow, TranscriptRowKind};
-        use serde_json::json;
-
-        let sid = Uuid::from_u128(141);
-        let mut app = structured_app(sid);
-        app.dispatch(Action::AttachHighlighted);
-        assert_eq!(app.state.focus, Focus::Pane);
-        assert_eq!(app.state.mode, Mode::Normal);
-        let handle = app.structured.get(&sid).unwrap().clone();
-        {
-            let mut state = handle.state.lock().unwrap();
-            state.rows = vec![
-                TranscriptRow {
-                    id: "text".into(),
-                    kind: TranscriptRowKind::AgentText,
-                    data: json!({"content":{"type":"text","text":"hello"}}),
-                },
-                TranscriptRow {
-                    id: "approval".into(),
-                    kind: TranscriptRowKind::Approval,
-                    data: json!({"options":[{"kind":"allow_once"}]}),
-                },
-            ];
-            state.selected = Some("text".into());
-            state.reduced = ReducedState {
-                pending_approval: Some(json!({"nonce":"n"})),
-                ..ReducedState::default()
-            };
-        }
-
-        assert_eq!(
-            app.handle_structured_key(&InputKey::char('j')),
-            Some(vec![])
-        );
-        assert_eq!(
-            app.handle_structured_key(&InputKey::char('a')),
-            Some(vec![Effect::StructuredApproval {
-                id: sid,
-                nonce: "n".into(),
-                decision: StructuredApprovalDecision::AllowOnce,
-            }])
-        );
-        assert_eq!(
-            handle.state.lock().unwrap().selected.as_deref(),
-            Some("approval")
-        );
-    }
-
-    #[test]
-    fn structured_insert_mode_edits_submits_and_cancels_without_pty_bytes() {
-        let sid = Uuid::from_u128(141);
-        let mut app = structured_app(sid);
-        assert!(app.emulators.get(sid).is_none());
-        app.forward_to_session(&InputKey::char('h'));
-        app.forward_to_session(&InputKey::char('i'));
-        assert_eq!(
-            app.forward_to_session(&InputKey::Enter),
-            Some(Effect::StructuredPrompt {
-                id: sid,
-                prompt: "hi".into(),
-            })
-        );
-        assert_eq!(
-            app.handle_structured_key(&InputKey::Esc),
-            Some(vec![Effect::StructuredCancel { id: sid }])
-        );
-        assert_eq!(
-            app.forward_literal_to_terminal(&app.cfg.leader.clone()),
-            None
-        );
-    }
 }

crates/maestro-tui/src/catalog.rs

@@ -207,7 +207,6 @@ mod tests {
 
     fn session(id: u128, command: &str) -> Session {
         Session {
-            view: Default::default(),
             id: Uuid::from_u128(id),
             command: command.into(),
             cwd: std::path::PathBuf::from("/tmp"),
@@ -224,9 +223,7 @@ mod tests {
             current_cwd: None,
             blocked_work: None,
             last_focused_at: None,
-            acp_session_id: None,
-            auto_approve: false,
-            queued_prompts: Vec::new(),
+            agent_session_id: None,
         }
     }
 

crates/maestro-tui/src/command_bar.rs

@@ -194,7 +194,9 @@ pub enum BarOutcome {
 pub fn order_sessions_for_bar(sessions: &[Session]) -> Vec<&Session> {
     let mut ordered: Vec<&Session> = sessions.iter().collect();
     ordered.sort_by(|a, b| {
-        let dead = |s: &Session| u8::from(s.status == SessionStatus::Dead);
+        // docs/COMMAND-BAR.md: anything with no live pane — dead or dormant
+        // (#162) — sorts after the sessions you could actually attach to.
+        let dead = |s: &Session| u8::from(s.status != SessionStatus::Running);
         dead(a)
             .cmp(&dead(b))
             .then_with(|| {
@@ -319,7 +321,7 @@ impl CommandBar {
             .map(|s| BarEntry {
                 candidate: MatchCandidate::Session(session_candidate(s, home_dir)),
                 target: BarTarget::Session(s.id),
-                dead: s.status == SessionStatus::Dead,
+                dead: s.status != SessionStatus::Running,
                 chords: Vec::new(),
             })
             .collect();
@@ -793,7 +795,6 @@ mod tests {
 
     fn session(n: u128, command: &str) -> Session {
         Session {
-            view: Default::default(),
             id: Uuid::from_u128(n),
             cwd: PathBuf::from("/home/me/dev/api"),
             command: command.to_string(),
@@ -810,9 +811,7 @@ mod tests {
             current_cwd: None,
             blocked_work: None,
             last_focused_at: None,
-            acp_session_id: None,
-            auto_approve: false,
-            queued_prompts: Vec::new(),
+            agent_session_id: None,
         }
     }
 
@@ -893,6 +892,23 @@ mod tests {
         assert!(bar.rows()[1].dead);
     }
 
+    /// #162: docs/COMMAND-BAR.md ranks by whether you could attach, not by
+    /// which way the pane went away — a dormant session sorts with the dead.
+    #[test]
+    fn dormant_sessions_sort_after_live_ones_however_recent() {
+        let mut dormant = named(1, "dormant");
+        dormant.status = SessionStatus::Dormant;
+        dormant.last_focused_at = Some(at(99));
+        let live = named(2, "live");
+
+        let bar = CommandBar::new(&[dormant, live], &[], "/home/me");
+        assert_eq!(
+            ids(bar.rows()),
+            vec![Uuid::from_u128(2), Uuid::from_u128(1)]
+        );
+        assert!(bar.rows()[1].dead);
+    }
+
     #[test]
     fn typing_ranks_through_the_matcher_and_returns_ranges() {
         let mut bar = CommandBar::new(

crates/maestro-tui/src/draft.rs

@@ -41,10 +41,8 @@ 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::{
-    BranchInfo, CreateSessionRequest, Project, SessionView, SpawnPreset, WorktreeSpec,
-};
+use maestro_protocol::display::abbreviate_dir;
+use maestro_protocol::{BranchInfo, CreateSessionRequest, Project, SpawnPreset, WorktreeSpec};
 use ratatui::layout::{Constraint, Layout, Rect};
 use ratatui::style::{Modifier, Style};
 use ratatui::text::{Line, Span};
@@ -88,11 +86,9 @@ pub enum DraftField {
     /// apply immediately, mirroring the web form's per-click choice.
     WorktreeChoice,
     Name,
-    /// Disclosure collapsing the optional view and worktree controls below.
+    /// Disclosure collapsing the worktree/branch controls below (#93).
     /// Closed by default; Enter / Space toggles.
     Advanced,
-    /// ACP-backed transcript instead of a terminal. Claude Code or Codex.
-    StructuredToggle,
     /// Worktree on/off for this session (#65). Enter / Space toggles.
     WorktreeToggle,
     /// New-vs-existing branch source; Left / Right switches.
@@ -255,14 +251,6 @@ 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
-    /// command is Claude Code or Codex, and on by default whenever it is —
-    /// 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 +291,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,
@@ -323,8 +311,6 @@ impl Default for DraftPane {
             name_touched: false,
             worktree_enabled: true,
             advanced_collapsed: true,
-            structured_view: false,
-            structured_view_touched: false,
             base_repo: None,
             probed_cwd: None,
             probe_seq: 0,
@@ -343,11 +329,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 +348,6 @@ impl DraftPane {
             .position(|p| !p.command.is_empty())
             .unwrap_or(0);
         self.apply_seed_command();
-        self.sync_structured_view();
     }
 
     /// Land a seeded command on the tile that runs it: its own preset when the
@@ -682,28 +663,6 @@ impl DraftPane {
         }
     }
 
-    fn supports_structured_view(&self) -> bool {
-        supports_structured_view(self.command())
-    }
-
-    /// Re-resolve the toggle after the command changed: an unsupported
-    /// 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;
-        }
-    }
-
     /// The chosen working directory: a picked project row, else the raw path
     /// input when it holds something.
     pub fn cwd(&self) -> Option<PathBuf> {
@@ -734,22 +693,12 @@ impl DraftPane {
             );
         }
         let worktree = self.build_worktree()?;
-        let auto_approve = self
-            .presets
-            .get(self.selected_preset)
-            .is_some_and(|p| p.auto_approve);
         Ok(CreateSessionRequest {
-            view: if self.structured_view && self.supports_structured_view() {
-                SessionView::Structured
-            } else {
-                SessionView::Terminal
-            },
             cwd,
             command: command.to_string(),
             env: Default::default(),
             metadata,
             worktree,
-            auto_approve,
         })
     }
 
@@ -804,9 +753,6 @@ impl DraftPane {
         order.push(DraftField::Name);
         order.push(DraftField::Advanced);
         if !self.advanced_collapsed {
-            if self.supports_structured_view() {
-                order.push(DraftField::StructuredToggle);
-            }
             if !self.cwd_raw_visible && self.selected_group_key.is_some() {
                 order.push(DraftField::WorktreeChoice);
             }
@@ -848,7 +794,6 @@ impl DraftPane {
         }
         self.selected_preset =
             ((self.selected_preset as i32) + delta).rem_euclid(len as i32) as usize;
-        self.sync_structured_view();
     }
 
     /// Step-one boxes surviving the type-to-filter, in display order. A
@@ -1055,9 +1000,9 @@ impl DraftPane {
             // Two fields keep their own Enter instead: `DirPicker`, whose
             // highlighted row isn't the picked one until a first Enter chooses
             // it (the next Enter, now that it's active, falls through to
-            // submit); and the disclosure/checkbox fields, which activate on
-            // Enter like buttons rather than submitting, matching the web
-            // form controls.
+            // submit); and the disclosure/toggle pair (`Advanced`,
+            // `WorktreeToggle`), which activate on Enter like a button rather
+            // than submitting, same as the web form's own `<button>` controls.
             InputKey::Enter if self.focused_field == DraftField::DirPicker => {
                 let is_other_row = self.selection() >= self.visible_groups().len();
                 let choose_only =
@@ -1077,10 +1022,6 @@ impl DraftPane {
                 self.toggle_worktree();
                 DraftInputResult::Consumed
             }
-            InputKey::Enter if self.focused_field == DraftField::StructuredToggle => {
-                self.toggle_structured_view();
-                DraftInputResult::Consumed
-            }
             InputKey::Enter => DraftInputResult::Submit,
             InputKey::Char {
                 c: ' ',
@@ -1098,14 +1039,6 @@ impl DraftPane {
                 self.toggle_worktree();
                 DraftInputResult::Consumed
             }
-            InputKey::Char {
-                c: ' ',
-                ctrl: false,
-                ..
-            } if self.focused_field == DraftField::StructuredToggle => {
-                self.toggle_structured_view();
-                DraftInputResult::Consumed
-            }
             InputKey::Up if self.focused_field == DraftField::DirPicker => {
                 self.move_selection(-1);
                 DraftInputResult::Consumed
@@ -1149,10 +1082,7 @@ impl DraftPane {
             other => {
                 match self.focused_field {
                     DraftField::Preset | DraftField::Submit => {}
-                    DraftField::CustomCommand => {
-                        self.custom_command.handle_key(other);
-                        self.sync_structured_view();
-                    }
+                    DraftField::CustomCommand => self.custom_command.handle_key(other),
                     // Typing filters the list; the highlight resets to the top
                     // so a narrowed search always starts at its best match.
                     DraftField::DirPicker => {
@@ -1190,9 +1120,9 @@ impl DraftPane {
 
         let show_custom = self.is_custom();
         let show_raw = self.cwd_raw_visible;
-        let show_structured = !self.advanced_collapsed && self.supports_structured_view();
-        // Optional view and worktree controls stay behind the "Advanced
-        // options" disclosure (#93), regardless of what they'd otherwise show.
+        // The worktree choice step, the worktree toggle and its body all stay
+        // behind the "Advanced options" disclosure (#93): collapsed hides
+        // them, regardless of what they'd otherwise show.
         let show_wt_toggle = !self.advanced_collapsed;
         let show_wt_body = show_wt_toggle && self.worktree_body_visible();
         let show_wt_choice =
@@ -1211,7 +1141,6 @@ impl DraftPane {
         let fixed: u16 = 3 /* tiles + dir + name */ + 1 /* advanced header */ + 1 /* spawn */
             + u16::from(show_custom)
             + u16::from(show_raw)
-            + u16::from(show_structured)
             + u16::from(show_wt_toggle)
             + u16::from(show_wt_choice) * wt_choice_capacity
             + u16::from(show_wt_body) * (1 + if self.branch_mode == WorktreeBranchMode::New { 1 } else { branch_rows })
@@ -1231,9 +1160,6 @@ impl DraftPane {
         }
         constraints.push(Constraint::Length(1)); // name
         constraints.push(Constraint::Length(1)); // advanced header
-        if show_structured {
-            constraints.push(Constraint::Length(1));
-        }
         if show_wt_choice {
             constraints.push(Constraint::Length(wt_choice_capacity));
         }
@@ -1432,24 +1358,6 @@ impl DraftPane {
             advanced_row,
         );
 
-        if show_structured {
-            let row = next_row();
-            f.render_widget(
-                Paragraph::new(Line::from(vec![
-                    Span::raw(format!("{:<GUTTER$}", "view:")),
-                    Span::styled(
-                        if self.structured_view {
-                            "[x] structured view"
-                        } else {
-                            "[ ] structured view"
-                        },
-                        field_style(DraftField::StructuredToggle),
-                    ),
-                ])),
-                row,
-            );
-        }
-
         if show_wt_choice {
             // Step two (#96 rule 3): "+ new" first, then the repository's
             // worktrees newest-first.
@@ -1797,7 +1705,7 @@ mod tests {
             id: "aider".into(),
             label: "Aider".into(),
             command: "aider".into(),
-            auto_approve: false,
+            resume_command: None,
         }]);
         assert_eq!(
             draft.command(),
@@ -1820,13 +1728,13 @@ mod tests {
                 id: "claude".into(),
                 label: "Claude".into(),
                 command: "claude".into(),
-                auto_approve: false,
+                resume_command: None,
             },
             SpawnPreset {
                 id: "aider".into(),
                 label: "Aider".into(),
                 command: "aider".into(),
-                auto_approve: false,
+                resume_command: None,
             },
         ]);
         assert_eq!(draft.command(), "aider");
@@ -1846,7 +1754,7 @@ mod tests {
             id: "claude".into(),
             label: "Claude".into(),
             command: "claude".into(),
-            auto_approve: false,
+            resume_command: None,
         }]);
         assert!(draft.is_custom());
         assert_eq!(draft.command(), "bash -l");
@@ -1912,280 +1820,6 @@ mod tests {
         assert_eq!(req.cwd, PathBuf::from("/srv/work"));
     }
 
-    #[test]
-    fn structured_view_is_default_on_and_visible_for_supported_agents() {
-        let mut draft = DraftPane {
-            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,
-            },
-            SpawnPreset {
-                id: "opencode".into(),
-                label: "OpenCode".into(),
-                command: "opencode".into(),
-                auto_approve: false,
-            },
-        ]);
-        assert!(draft.structured_view, "on by default for a supported agent");
-        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}");
-
-        draft.cycle_preset(1);
-        assert_eq!(draft.command(), "codex");
-        assert!(
-            draft.structured_view,
-            "Codex keeps the structured selection"
-        );
-        draft.cycle_preset(1);
-        assert_eq!(draft.command(), "opencode");
-        assert!(
-            !draft.structured_view,
-            "a hidden value must not stay checked"
-        );
-        assert!(!draft.field_order().contains(&DraftField::StructuredToggle));
-        let rendered = render_to_string(100, 24, |f| draft.render(f, f.area(), true));
-        assert!(!rendered.contains("structured view"), "{rendered}");
-    }
-
-    #[test]
-    fn structured_view_request_is_guarded_against_a_stale_command() {
-        let mut draft = DraftPane {
-            picked_cwd: Some(PathBuf::from("/srv/work")),
-            worktree_enabled: false,
-            structured_view: true,
-            ..DraftPane::default()
-        };
-        assert_eq!(draft.build_request().unwrap().view, SessionView::Structured);
-
-        draft.selected_preset = 1;
-        assert_eq!(draft.command(), "opencode");
-        assert_eq!(draft.build_request().unwrap().view, SessionView::Terminal);
-    }
-
-    /// A custom command typed into the free-text field, run through the same
-    /// resolver the daemon/web gate uses (`command_tool`, #199): a path, an
-    /// env prefix, or a wrapper still resolves to Claude Code or Codex, so
-    /// the toggle stays offered and the request carries `Structured`; an
-    /// unrelated program does not.
-    #[test]
-    fn structured_view_follows_command_resolution_for_custom_commands() {
-        let cases: &[(&str, bool)] = &[
-            ("claude", true),
-            ("claude --resume", true),
-            ("CLAUDE", true),
-            ("/usr/local/bin/claude -p hi", true),
-            ("./bin/claude", true),
-            ("FOO=1 BAR=2 claude", true),
-            ("npx claude-code", true),
-            ("npx --yes claude-code", true),
-            ("sudo claude", true),
-            ("sudo -u root claude", true),
-            ("env -i claude", true),
-            ("nohup claude", true),
-            ("time claude", true),
-            ("command claude", true),
-            ("pnpm --silent dlx claude-code", true),
-            ("yarn --silent dlx claude-code", true),
-            ("bun x claude-code", true),
-            ("\"/opt/my agent/claude\" --resume", true),
-            ("codex", true),
-            ("codex --full-auto", true),
-            ("CODEX=1 codex", true),
-            ("/usr/local/bin/codex exec", true),
-            ("npx codex", true),
-            ("sudo -u root codex", true),
-            ("env -i codex", true),
-            ("command codex", true),
-            ("pnpm --silent dlx codex", true),
-            ("\"/opt/my agent/codex\" exec", true),
-            ("bash", false),
-            ("opencode", false),
-            ("/usr/local/bin/bash -l", false),
-            // A package-manager wrapper without `dlx`/`x` runs a
-            // `package.json` script, not the package (#199) — must not be
-            // mistaken for a Claude launch.
-            ("pnpm claude", false),
-            ("yarn claude", false),
-            // The daemon's structured-session child, never a valid
-            // user-facing launch form (#199).
-            ("claude-code-acp", false),
-        ];
-        for &(command, supported) in cases {
-            let mut draft = DraftPane {
-                picked_cwd: Some(PathBuf::from("/srv/work")),
-                worktree_enabled: false,
-                advanced_collapsed: false,
-                ..DraftPane::default()
-            };
-            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:?}"
-            );
-            assert_eq!(
-                draft.structured_view, supported,
-                "default selection for {command:?}"
-            );
-            let view = draft.build_request().unwrap().view;
-            assert_eq!(
-                view,
-                if supported {
-                    SessionView::Structured
-                } else {
-                    SessionView::Terminal
-                },
-                "request view for {command:?}"
-            );
-
-            draft.toggle_structured_view();
-            assert!(
-                !draft.structured_view,
-                "the toggle turns the default off for {command:?}"
-            );
-        }
-    }
-
-    /// A configured preset (the spawn-form "alias" for a command) is gated
-    /// the same way as free text: a preset whose command resolves to Claude
-    /// Code or Codex through a wrapper still offers structured view.
-    #[test]
-    fn structured_view_follows_command_resolution_for_presets() {
-        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-wrapped".into(),
-                label: "Claude (npx)".into(),
-                command: "npx claude-code --resume".into(),
-                auto_approve: false,
-            },
-            SpawnPreset {
-                id: "codex-wrapped".into(),
-                label: "Codex (npx)".into(),
-                command: "npx codex exec".into(),
-                auto_approve: false,
-            },
-            SpawnPreset {
-                id: "aider".into(),
-                label: "Aider".into(),
-                command: "aider".into(),
-                auto_approve: false,
-            },
-        ]);
-
-        assert_eq!(draft.command(), "npx claude-code --resume");
-        assert!(draft.field_order().contains(&DraftField::StructuredToggle));
-        assert!(draft.structured_view);
-        assert_eq!(draft.build_request().unwrap().view, SessionView::Structured);
-
-        // Switching between supported presets preserves the selection.
-        draft.cycle_preset(1);
-        assert_eq!(draft.command(), "npx codex exec");
-        assert!(draft.structured_view);
-        assert_eq!(draft.build_request().unwrap().view, SessionView::Structured);
-
-        // Switching to a preset that does not resolve to an ACP agent clears the
-        // stale selection instead of letting an invalid request through.
-        draft.cycle_preset(1);
-        assert_eq!(draft.command(), "aider");
-        assert!(!draft.structured_view, "stale selection must clear");
-        assert!(!draft.field_order().contains(&DraftField::StructuredToggle));
-        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`.
-    #[test]
-    fn structured_view_clears_when_custom_command_edited_away_from_supported_agent() {
-        let mut draft = DraftPane {
-            picked_cwd: Some(PathBuf::from("/srv/work")),
-            worktree_enabled: false,
-            advanced_collapsed: false,
-            focused_field: DraftField::CustomCommand,
-            ..DraftPane::default()
-        };
-        draft.selected_preset = draft.presets.len() - 1;
-        draft.custom_command = crate::text_input::TextInput::with_value("codex");
-        draft.sync_structured_view();
-        assert!(draft.structured_view);
-
-        typed(&mut draft, " -p");
-        assert_eq!(draft.command(), "codex -p");
-        assert!(draft.structured_view, "still Codex, selection survives");
-
-        for _ in 0.."codex -p".chars().count() {
-            draft.on_input(&InputKey::Backspace);
-        }
-        typed(&mut draft, "bash");
-        assert_eq!(draft.command(), "bash");
-        assert!(
-            !draft.structured_view,
-            "editing the program away from Codex clears the stale selection"
-        );
-        assert_eq!(draft.build_request().unwrap().view, SessionView::Terminal);
-    }
-
     #[test]
     fn projects_render_sorted_with_stale_dimmed_and_other_directory_last() {
         let mut draft = DraftPane {

crates/maestro-tui/src/fast_forward.rs

@@ -108,7 +108,6 @@ impl FastForwardDefaults {
             return None;
         }
         Some(CreateSessionRequest {
-            view: Default::default(),
             cwd: project.path.clone(),
             command: command.to_string(),
             env: Default::default(),
@@ -121,7 +120,6 @@ impl FastForwardDefaults {
                 branch: handle.to_string(),
                 create_branch: true,
             }),
-            auto_approve: false,
         })
     }
 
@@ -185,7 +183,7 @@ mod tests {
             id: id.into(),
             label: id.into(),
             command: command.into(),
-            auto_approve: false,
+            resume_command: None,
         }
     }
 

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/lib.rs

@@ -23,8 +23,6 @@ pub mod render;
 pub mod session_task;
 pub mod sidebar;
 pub mod state;
-pub mod structured_pane;
-pub mod structured_task;
 pub mod terminal;
 pub mod text_input;
 

crates/maestro-tui/src/palette.rs

@@ -82,7 +82,7 @@ impl Surface {
     pub fn activity(&self, state: ActivityState) -> Color {
         match state {
             ActivityState::Active => self.active,
-            ActivityState::Idle | ActivityState::Starting => self.idle,
+            ActivityState::Idle => self.idle,
             ActivityState::AwaitingInput => self.awaiting,
             ActivityState::Error => self.error,
         }
@@ -928,10 +928,9 @@ pub fn contrast_ratio(a: Color, b: Color) -> Option<f64> {
 mod tests {
     use super::*;
 
-    const STATES: [ActivityState; 5] = [
+    const STATES: [ActivityState; 4] = [
         ActivityState::Active,
         ActivityState::Idle,
-        ActivityState::Starting,
         ActivityState::AwaitingInput,
         ActivityState::Error,
     ];

crates/maestro-tui/src/render.rs

@@ -18,7 +18,6 @@ use crate::palette;
 use crate::pane::Pane;
 use crate::sidebar::Sidebar;
 use crate::state::{AppState, Focus, OverlayKind, SidebarItem};
-use crate::structured_pane::StructuredPane;
 
 /// Tagged regions for mouse hit-testing. The input router resolves a mouse
 /// coordinate to one of these via [`RegionMap::region_at`].
@@ -81,7 +80,6 @@ pub struct RenderInputs<'a> {
     pub home_dir: &'a str,
     pub pane_title: &'a str,
     pub pane: Option<&'a Pane>,
-    pub structured_pane: Option<&'a StructuredPane>,
     /// The spawn form behind [`OverlayKind::Spawn`], when one is up.
     pub draft: Option<&'a crate::draft::DraftPane>,
     pub state: &'a AppState,
@@ -149,22 +147,14 @@ pub fn draw(f: &mut Frame, inputs: RenderInputs<'_>) -> RegionMap {
     render_title_bar(f, title_area, inputs.pane_title, pane_focused);
     if let Some(p) = inputs.pane {
         p.render(f, pane_area);
-    } else if let Some(p) = inputs.structured_pane {
-        p.render(f, pane_area);
     }
     // `RegionMap::pane` is also the PTY resize source. The title bar is
-    // chrome; every remaining cell belongs to the active session pane.
+    // chrome; every remaining cell belongs to the emulator.
     map.pane = Some(pane_area);
 
     // Status bar — always visible, never eclipsed by overlays so the user can
     // always see the current mode + key hints.
-    render_status_bar(
-        f,
-        status_area,
-        inputs.state,
-        inputs.link,
-        inputs.structured_pane.is_some(),
-    );
+    render_status_bar(f, status_area, inputs.state, inputs.link);
 
     match inputs.state.overlay() {
         Some(OverlayKind::Spawn) => {
@@ -263,13 +253,7 @@ fn render_title_bar(f: &mut Frame, area: Rect, title: &str, focused: bool) {
 /// Render the always-visible status bar at the bottom of the frame. Surfaces
 /// mode + focused panel + the most useful key hints so the user is never
 /// guessing what state they're in.
-fn render_status_bar(
-    f: &mut Frame,
-    area: Rect,
-    state: &AppState,
-    link: &LinkStatus,
-    structured: bool,
-) {
+fn render_status_bar(f: &mut Frame, area: Rect, state: &AppState, link: &LinkStatus) {
     // The daemon indicator is pinned right and sized to its own text, so a
     // narrow terminal truncates the key hints rather than the release.
     let label = link_label(link);
@@ -287,13 +271,9 @@ fn render_status_bar(
         Focus::Sidebar => "sidebar",
         Focus::Pane => "pane",
     };
-    let hint = match (structured && state.focus == Focus::Pane, state.mode) {
-        (true, Mode::Normal) => "j/k: rows  •  enter: expand  •  i: compose  •  esc: cancel",
-        (true, Mode::Insert) => "enter: send  •  esc: cancel  •  ^a: sidebar",
-        (false, Mode::Normal) => {
-            "j/k: nav  •  enter: attach  •  s: spawn  •  ?: help  •  ^Wq: quit"
-        }
-        (false, Mode::Insert) => "^a: return to sidebar",
+    let hint = match state.mode {
+        Mode::Normal => "j/k: nav  •  enter: attach  •  s: spawn  •  ?: help  •  ^Wq: quit",
+        Mode::Insert => "^a: return to sidebar",
     };
     let mode_style = palette::active().mode_style(state.mode == Mode::Insert);
     let line = ratatui::text::Line::from(vec![
@@ -455,7 +435,6 @@ mod tests {
             home_dir: "",
             pane_title: "session",
             pane: None,
-            structured_pane: None,
             draft: None,
             state: &state,
             help: &help,
@@ -553,7 +532,6 @@ mod tests {
             home_dir: "",
             pane_title: "session",
             pane: None,
-            structured_pane: None,
             draft: Some(&draft),
             state: &state,
             help: &help,
@@ -609,7 +587,6 @@ mod tests {
                 home_dir: "",
                 pane_title: "session",
                 pane: None,
-                structured_pane: None,
                 draft: None,
                 state: &state,
                 help: &help,
@@ -652,7 +629,6 @@ mod tests {
                 home_dir: "",
                 pane_title: "session",
                 pane: None,
-                structured_pane: None,
                 draft: None,
                 state: &state,
                 help: &help,

crates/maestro-tui/src/session_task.rs

@@ -221,7 +221,7 @@ impl SessionTask {
     }
 }
 
-pub(crate) fn jitter(base: Duration) -> Duration {
+fn jitter(base: Duration) -> Duration {
     let ms = base.as_millis() as u64;
     let now_nanos = std::time::SystemTime::now()
         .duration_since(std::time::UNIX_EPOCH)

crates/maestro-tui/src/sidebar.rs

@@ -268,6 +268,8 @@ impl Sidebar {
     fn name_row(&self, s: &Session, width: usize, focused: bool) -> Vec<Span<'static>> {
         let glyph = match (s.status, self.attached.contains(&s.id)) {
             (SessionStatus::Dead, _) => "✗",
+            // #162: known from its sidecar, nothing running behind it.
+            (SessionStatus::Dormant, _) => "◌",
             (SessionStatus::Running, true) => "●",
             (SessionStatus::Running, false) => "○",
         };
@@ -322,6 +324,7 @@ impl Sidebar {
         // on line 1; the kill confirm names the specifics.
         let blocked = s.blocked_work.filter(|b| !b.is_clear());
         let dead = s.status == SessionStatus::Dead;
+        let dormant = s.status == SessionStatus::Dormant;
         let highlighted = self.highlight == Some(SidebarItem::Session(s.id));
         let fill = self.card_fill(s, focused);
         let base = card_base(fill, focused);
@@ -361,6 +364,9 @@ impl Sidebar {
         if dead {
             tail.push(Span::styled(" exited", muted));
         }
+        if dormant {
+            tail.push(Span::styled(" dormant", muted));
+        }
         // docs/SIDEBAR.md: the card names the program, never its arguments.
         let command = Span::styled(format!(" {}", command_program(&s.command)), muted);
 
@@ -484,7 +490,6 @@ mod tests {
         let mut metadata = HashMap::new();
         metadata.insert("name".into(), serde_json::Value::String(name.into()));
         Session {
-            view: Default::default(),
             id: Uuid::from_u128(id),
             command: "bash".into(),
             cwd: std::path::PathBuf::from("/tmp"),
@@ -501,9 +506,7 @@ mod tests {
             current_cwd: None,
             blocked_work: None,
             last_focused_at: None,
-            acp_session_id: None,
-            auto_approve: false,
-            queued_prompts: Vec::new(),
+            agent_session_id: None,
         }
     }
 
@@ -981,7 +984,6 @@ mod tests {
         for state in [
             ActivityState::Active,
             ActivityState::Idle,
-            ActivityState::Starting,
             ActivityState::AwaitingInput,
             ActivityState::Error,
         ] {
@@ -1012,7 +1014,6 @@ mod tests {
         for state in [
             ActivityState::Active,
             ActivityState::Idle,
-            ActivityState::Starting,
             ActivityState::AwaitingInput,
             ActivityState::Error,
         ] {
@@ -1074,6 +1075,39 @@ mod tests {
         );
     }
 
+    /// #162, docs/SIDEBAR.md: a dormant session is known but not running —
+    /// its own glyph on line 1 and the muted `dormant` fragment on line 2, so
+    /// it never reads as something that exited.
+    #[test]
+    fn dormant_session_reads_as_known_but_not_running() {
+        let mut s = session_named(1, "claude");
+        s.status = SessionStatus::Dormant;
+        s.activity_since = Utc::now() - Duration::seconds(5);
+        let sb = Sidebar {
+            sessions: vec![s],
+            highlight: None,
+            attached: Default::default(),
+            pane_session: None,
+        };
+        let all = rows(&draw(&sb, 28, 8));
+        let idx = all.iter().position(|l| l.contains("claude")).unwrap();
+        assert!(
+            all[idx].contains('\u{25cc}'),
+            "expected the dormant glyph in: {:?}",
+            all[idx]
+        );
+        assert!(
+            all[idx + 1].contains("dormant"),
+            "expected dormant fragment in: {:?}",
+            all[idx + 1]
+        );
+        assert!(
+            !all[idx + 1].contains("exited"),
+            "a dormant session never reads as exited: {:?}",
+            all[idx + 1]
+        );
+    }
+
     /// docs/SIDEBAR.md: line 2 names the program, never its arguments.
     #[test]
     fn meta_line_drops_the_commands_arguments() {
@@ -1256,7 +1290,6 @@ mod tests {
     #[test]
     fn falls_back_to_command_when_name_metadata_is_absent() {
         let s = Session {
-            view: Default::default(),
             id: Uuid::from_u128(1),
             command: "vim".into(),
             cwd: std::path::PathBuf::from("/tmp"),
@@ -1273,9 +1306,7 @@ mod tests {
             current_cwd: None,
             blocked_work: None,
             last_focused_at: None,
-            acp_session_id: None,
-            auto_approve: false,
-            queued_prompts: Vec::new(),
+            agent_session_id: None,
         };
         let sb = Sidebar {
             sessions: vec![s],

crates/maestro-tui/src/structured_task.rs

@@ -1,773 +0,0 @@
-//! Live projection state for one structured session.
-
-use std::collections::HashSet;
-use std::sync::atomic::{AtomicU64, AtomicU8, Ordering};
-use std::sync::{Arc, Mutex};
-use std::time::Duration;
-
-use futures_util::StreamExt;
-use maestro_protocol::{
-    ReducedState, StructuredApprovalDecision, StructuredEvent, TranscriptDelta, TranscriptRow,
-    TranscriptRowKind,
-};
-use tokio::sync::watch;
-use tokio_tungstenite::tungstenite::{Error as WsError, Message};
-
-use crate::input::InputKey;
-use crate::session_task::SessionState;
-use crate::text_input::TextInput;
-
-/// Renderer and input state built directly from the daemon's two projections.
-#[derive(Debug, Clone)]
-pub struct StructuredState {
-    pub rows: Vec<TranscriptRow>,
-    pub reduced: ReducedState,
-    pub selected: Option<String>,
-    pub expanded: HashSet<String>,
-    pub scroll: usize,
-    /// Row id per rendered line from the last render pass, parallel to that
-    /// pass's `lines`. Lets the next render translate `scroll` — a raw index
-    /// into that now-stale layout — back into a row identity before mapping
-    /// it onto the freshly rebuilt layout, so growth/shrinkage above the
-    /// viewport shifts indices without shifting what's on screen.
-    pub(crate) line_rows: Vec<Option<String>>,
-    pub follow_selection: bool,
-    pub composer: TextInput,
-    pub error: Option<String>,
-    submitting: bool,
-    submission_generation: u64,
-    reconcile_submission_on_snapshot: Option<u64>,
-    approval_submitting: bool,
-}
-
-impl Default for StructuredState {
-    fn default() -> Self {
-        Self {
-            rows: Vec::new(),
-            reduced: ReducedState::default(),
-            selected: None,
-            expanded: HashSet::new(),
-            scroll: 0,
-            line_rows: Vec::new(),
-            follow_selection: true,
-            composer: TextInput::default(),
-            error: None,
-            submitting: false,
-            submission_generation: 0,
-            reconcile_submission_on_snapshot: None,
-            approval_submitting: false,
-        }
-    }
-}
-
-impl StructuredState {
-    pub fn apply(&mut self, event: StructuredEvent) {
-        match event {
-            StructuredEvent::TranscriptSnapshot { snapshot } => {
-                let selected = self.selected.clone();
-                self.rows = snapshot.rows;
-                self.selected = selected
-                    .filter(|id| self.rows.iter().any(|row| &row.id == id))
-                    .or_else(|| {
-                        self.rows
-                            .iter()
-                            .rev()
-                            .find(|row| row.kind != TranscriptRowKind::Plan)
-                            .map(|row| row.id.clone())
-                    });
-                self.expanded
-                    .retain(|id| self.rows.iter().any(|row| &row.id == id));
-            }
-            StructuredEvent::ReducedState { state } => {
-                let reconcile_submission = self
-                    .reconcile_submission_on_snapshot
-                    .take()
-                    .is_some_and(|generation| {
-                        self.submitting && generation == self.submission_generation
-                    });
-                self.apply_reduced(state, reconcile_submission);
-            }
-            StructuredEvent::ProjectionUpdate { transcript, state } => {
-                if let Some(delta) = transcript {
-                    self.apply_delta(delta);
-                }
-                self.apply_reduced(state, false);
-            }
-        }
-    }
-
-    fn apply_delta(&mut self, delta: TranscriptDelta) {
-        match delta {
-            TranscriptDelta::Append { row } => {
-                let followed_tail = self.follow_selection
-                    && self.selected.as_ref().is_some_and(|id| {
-                        self.rows
-                            .iter()
-                            .rev()
-                            .find(|old| old.kind != TranscriptRowKind::Plan)
-                            .is_some_and(|old| &old.id == id)
-                    });
-                if let Some(index) = self.rows.iter().position(|old| old.id == row.id) {
-                    self.rows[index] = row.clone();
-                } else {
-                    self.rows.push(row.clone());
-                }
-                if row.kind != TranscriptRowKind::Plan && (self.selected.is_none() || followed_tail)
-                {
-                    self.selected = Some(row.id);
-                }
-            }
-            TranscriptDelta::Patch { row } => {
-                if let Some(index) = self.rows.iter().position(|old| old.id == row.id) {
-                    self.rows[index] = row.clone();
-                } else {
-                    self.rows.push(row.clone());
-                }
-            }
-            TranscriptDelta::Remove { id } => {
-                let removed = self.rows.iter().position(|row| row.id == id);
-                self.rows.retain(|row| row.id != id);
-                self.expanded.remove(&id);
-                if self.selected.as_deref() == Some(&id) {
-                    self.selected = removed.and_then(|index| {
-                        let split = index.min(self.rows.len());
-                        self.rows[split..]
-                            .iter()
-                            .find(|row| row.kind != TranscriptRowKind::Plan)
-                            .or_else(|| {
-                                self.rows[..split]
-                                    .iter()
-                                    .rev()
-                                    .find(|row| row.kind != TranscriptRowKind::Plan)
-                            })
-                            .map(|row| row.id.clone())
-                    });
-                }
-            }
-        }
-    }
-
-    fn apply_reduced(&mut self, state: ReducedState, reconcile_submission: bool) {
-        let previous_nonce = self.pending_nonce().map(str::to_owned);
-        if reconcile_submission || state.turn.responding || state.turn.thinking {
-            self.submitting = false;
-        }
-        self.reduced = state;
-        let next_nonce = self.pending_nonce().map(str::to_owned);
-        if next_nonce != previous_nonce {
-            self.approval_submitting = false;
-            if next_nonce.is_some() {
-                self.selected = self
-                    .rows
-                    .iter()
-                    .rev()
-                    .find(|row| row.kind == TranscriptRowKind::Approval)
-                    .map(|row| row.id.clone());
-                self.follow_selection = true;
-            }
-        }
-    }
-
-    fn prepare_snapshot_reconciliation(&mut self) {
-        self.reconcile_submission_on_snapshot =
-            self.submitting.then_some(self.submission_generation);
-    }
-
-    pub fn select(&mut self, delta: isize) {
-        let selectable: Vec<&TranscriptRow> = self
-            .rows
-            .iter()
-            .filter(|row| row.kind != TranscriptRowKind::Plan)
-            .collect();
-        if selectable.is_empty() {
-            self.selected = None;
-            return;
-        }
-        let current = self
-            .selected
-            .as_ref()
-            .and_then(|id| selectable.iter().position(|row| &row.id == id))
-            .unwrap_or(selectable.len() - 1);
-        let next = if delta >= 0 {
-            current
-                .saturating_add(delta as usize)
-                .min(selectable.len() - 1)
-        } else {
-            current.saturating_sub(delta.unsigned_abs())
-        };
-        self.selected = Some(selectable[next].id.clone());
-        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;
-        };
-        let expandable = self.rows.iter().any(|row| {
-            row.id == id
-                && matches!(
-                    row.kind,
-                    TranscriptRowKind::ToolCall | TranscriptRowKind::ToolDiff
-                )
-        });
-        if !expandable {
-            return;
-        }
-        if !self.expanded.insert(id.clone()) {
-            self.expanded.remove(&id);
-        }
-        self.follow_selection = true;
-    }
-
-    pub fn scroll_by(&mut self, lines: isize) {
-        self.scroll = if lines >= 0 {
-            self.scroll.saturating_sub(lines as usize)
-        } else {
-            self.scroll.saturating_add(lines.unsigned_abs())
-        };
-        self.follow_selection = false;
-    }
-
-    pub fn edit_composer(&mut self, key: &InputKey) {
-        if !self.turn_active() {
-            self.composer.handle_key(key);
-            self.error = None;
-        }
-    }
-
-    pub fn begin_prompt(&mut self) -> Option<String> {
-        if self.turn_active() || self.composer.value().trim().is_empty() {
-            return None;
-        }
-        let prompt = self.composer.value().to_string();
-        self.composer = TextInput::default();
-        self.submission_generation = self.submission_generation.wrapping_add(1);
-        self.submitting = true;
-        self.error = None;
-        Some(prompt)
-    }
-
-    pub fn prompt_failed(&mut self, prompt: String, error: String) {
-        if self.composer.value().is_empty() {
-            self.composer = TextInput::with_value(prompt);
-        }
-        self.submitting = false;
-        self.error = Some(error);
-    }
-
-    pub fn turn_active(&self) -> bool {
-        self.submitting || self.reduced.turn.responding || self.reduced.turn.thinking
-    }
-
-    pub fn pending_nonce(&self) -> Option<&str> {
-        self.reduced
-            .pending_approval
-            .as_ref()?
-            .get("nonce")?
-            .as_str()
-    }
-
-    pub fn approval_decision(&mut self, key: char) -> Option<(String, StructuredApprovalDecision)> {
-        if self.approval_submitting {
-            return None;
-        }
-        let selected = self.selected.as_deref()?;
-        let pending_row = self
-            .rows
-            .iter()
-            .rev()
-            .find(|row| row.kind == TranscriptRowKind::Approval)?;
-        if pending_row.id != selected {
-            return None;
-        }
-        let decision = match key {
-            'a' => StructuredApprovalDecision::AllowOnce,
-            'A' => StructuredApprovalDecision::AllowForSession,
-            'd' => StructuredApprovalDecision::Deny,
-            _ => return None,
-        };
-        let offered = offered_decisions(&pending_row.data);
-        if !offered.contains(&decision) {
-            return None;
-        }
-        let nonce = self.pending_nonce()?.to_string();
-        self.approval_submitting = true;
-        self.error = None;
-        Some((nonce, decision))
-    }
-
-    pub fn approval_failed(&mut self, nonce: &str, error: String) {
-        if self.pending_nonce() != Some(nonce) {
-            return;
-        }
-        self.approval_submitting = false;
-        self.error = Some(error);
-    }
-}
-
-pub fn offered_decisions(data: &serde_json::Value) -> Vec<StructuredApprovalDecision> {
-    let mut out = Vec::new();
-    for kind in data
-        .get("options")
-        .and_then(serde_json::Value::as_array)
-        .into_iter()
-        .flatten()
-        .filter_map(|option| option.get("kind").and_then(serde_json::Value::as_str))
-    {
-        match kind {
-            "allow_once" if !out.contains(&StructuredApprovalDecision::AllowOnce) => {
-                out.push(StructuredApprovalDecision::AllowOnce)
-            }
-            "allow_always" if !out.contains(&StructuredApprovalDecision::AllowForSession) => {
-                out.push(StructuredApprovalDecision::AllowForSession)
-            }
-            "reject_once" | "reject_always" if !out.contains(&StructuredApprovalDecision::Deny) => {
-                out.push(StructuredApprovalDecision::Deny)
-            }
-            _ => {}
-        }
-    }
-    out
-}
-
-/// Cheap shared handle for a structured projection connection.
-#[derive(Clone)]
-pub struct StructuredHandle {
-    pub state: Arc<Mutex<StructuredState>>,
-    connection: Arc<AtomicU8>,
-    revision: Arc<AtomicU64>,
-    stop: watch::Sender<bool>,
-}
-
-impl std::fmt::Debug for StructuredHandle {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("StructuredHandle")
-            .field("connection", &self.connection())
-            .field("revision", &self.revision())
-            .finish_non_exhaustive()
-    }
-}
-
-impl StructuredHandle {
-    pub fn connection(&self) -> SessionState {
-        match self.connection.load(Ordering::Acquire) {
-            0 => SessionState::Connecting,
-            1 => SessionState::Live,
-            2 => SessionState::Reconnecting,
-            _ => SessionState::Ended,
-        }
-    }
-
-    pub fn revision(&self) -> u64 {
-        self.revision.load(Ordering::Acquire)
-    }
-
-    pub fn end(&self) {
-        self.connection
-            .store(SessionState::Ended as u8, Ordering::Release);
-        let _ = self.stop.send(true);
-    }
-
-    #[cfg(test)]
-    pub(crate) fn test_handle(state: StructuredState) -> Self {
-        let (stop, _) = watch::channel(false);
-        Self {
-            state: Arc::new(Mutex::new(state)),
-            connection: Arc::new(AtomicU8::new(SessionState::Live as u8)),
-            revision: Arc::new(AtomicU64::new(0)),
-            stop,
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct StructuredTask;
-
-impl StructuredTask {
-    pub fn spawn(ws_url: String) -> StructuredHandle {
-        let state = Arc::new(Mutex::new(StructuredState::default()));
-        let connection = Arc::new(AtomicU8::new(SessionState::Connecting as u8));
-        let revision = Arc::new(AtomicU64::new(0));
-        let (stop, mut stopped) = watch::channel(false);
-        let handle = StructuredHandle {
-            state: state.clone(),
-            connection: connection.clone(),
-            revision: revision.clone(),
-            stop,
-        };
-
-        tokio::spawn(async move {
-            let mut backoff = Duration::from_secs(1);
-            loop {
-                if *stopped.borrow() {
-                    return;
-                }
-                state
-                    .lock()
-                    .expect("structured state mutex")
-                    .prepare_snapshot_reconciliation();
-                connection.store(SessionState::Connecting as u8, Ordering::Release);
-                let connected = tokio::select! {
-                    result = tokio_tungstenite::connect_async(&ws_url) => result,
-                    _ = stopped.changed() => return,
-                };
-                let (mut ws, _) = match connected {
-                    Ok(value) => value,
-                    Err(error) => {
-                        if terminal_handshake_error(&error) {
-                            state.lock().expect("structured state mutex").error =
-                                Some(format!("cannot open structured session: {error}"));
-                            connection.store(SessionState::Ended as u8, Ordering::Release);
-                            revision.fetch_add(1, Ordering::Release);
-                            return;
-                        }
-                        connection.store(SessionState::Reconnecting as u8, Ordering::Release);
-                        revision.fetch_add(1, Ordering::Release);
-                        tokio::select! {
-                            _ = tokio::time::sleep(super::session_task::jitter(backoff)) => {},
-                            _ = stopped.changed() => return,
-                        }
-                        backoff = backoff.saturating_mul(2).min(Duration::from_secs(30));
-                        continue;
-                    }
-                };
-                backoff = Duration::from_secs(1);
-                connection.store(SessionState::Live as u8, Ordering::Release);
-                revision.fetch_add(1, Ordering::Release);
-
-                loop {
-                    let frame = tokio::select! {
-                        frame = ws.next() => frame,
-                        _ = stopped.changed() => return,
-                    };
-                    match frame {
-                        Some(Ok(Message::Text(text))) => {
-                            if let Ok(event) = serde_json::from_str::<StructuredEvent>(&text) {
-                                state.lock().expect("structured state mutex").apply(event);
-                                revision.fetch_add(1, Ordering::Release);
-                            }
-                        }
-                        Some(Ok(Message::Close(_))) | None | Some(Err(_)) => break,
-                        _ => {}
-                    }
-                }
-                connection.store(SessionState::Reconnecting as u8, Ordering::Release);
-                revision.fetch_add(1, Ordering::Release);
-                tokio::select! {
-                    _ = tokio::time::sleep(super::session_task::jitter(backoff)) => {},
-                    _ = stopped.changed() => return,
-                }
-                backoff = backoff.saturating_mul(2).min(Duration::from_secs(30));
-            }
-        });
-        handle
-    }
-}
-
-fn terminal_handshake_error(error: &WsError) -> bool {
-    matches!(error, WsError::Http(response) if response.status().is_client_error())
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use maestro_protocol::{TranscriptSnapshot, TurnState};
-    use serde_json::json;
-
-    fn row(id: &str, kind: TranscriptRowKind, data: serde_json::Value) -> TranscriptRow {
-        TranscriptRow {
-            id: id.into(),
-            kind,
-            data,
-        }
-    }
-
-    #[test]
-    fn snapshots_replace_and_deltas_address_rows_by_id() {
-        let mut state = StructuredState::default();
-        state.apply(StructuredEvent::TranscriptSnapshot {
-            snapshot: TranscriptSnapshot {
-                cursor: 2,
-                rows: vec![row("a", TranscriptRowKind::AgentText, json!({}))],
-            },
-        });
-        state.apply(StructuredEvent::ProjectionUpdate {
-            transcript: Some(TranscriptDelta::Patch {
-                row: row("a", TranscriptRowKind::AgentText, json!({"n": 2})),
-            }),
-            state: ReducedState::default(),
-        });
-        state.apply(StructuredEvent::ProjectionUpdate {
-            transcript: Some(TranscriptDelta::Append {
-                row: row("b", TranscriptRowKind::Notice, json!({})),
-            }),
-            state: ReducedState::default(),
-        });
-        assert_eq!(state.rows.len(), 2);
-        assert_eq!(state.rows[0].data["n"], 2);
-
-        state.apply(StructuredEvent::TranscriptSnapshot {
-            snapshot: TranscriptSnapshot {
-                cursor: 5,
-                rows: vec![row("b", TranscriptRowKind::Notice, json!({"fresh": true}))],
-            },
-        });
-        assert_eq!(state.rows.len(), 1);
-        assert_eq!(state.rows[0].data["fresh"], true);
-    }
-
-    #[test]
-    fn selection_survives_patch_and_moves_after_remove() {
-        let mut state = StructuredState {
-            rows: vec![
-                row("a", TranscriptRowKind::Notice, json!({})),
-                row("b", TranscriptRowKind::ToolCall, json!({})),
-                row("plan", TranscriptRowKind::Plan, json!({})),
-            ],
-            selected: Some("a".into()),
-            ..StructuredState::default()
-        };
-        state.select(1);
-        assert_eq!(state.selected.as_deref(), Some("b"));
-        state.toggle_selected();
-        assert!(state.expanded.contains("b"));
-        state.apply_delta(TranscriptDelta::Remove { id: "b".into() });
-        assert_eq!(state.selected.as_deref(), Some("a"));
-
-        state.apply_delta(TranscriptDelta::Remove { id: "a".into() });
-        assert_eq!(
-            state.selected, None,
-            "collapsed plan rows are not selectable"
-        );
-    }
-
-    #[test]
-    fn approval_keys_only_offer_server_backed_decisions() {
-        let mut state = StructuredState::default();
-        state.rows.push(row(
-            "approval:1",
-            TranscriptRowKind::Approval,
-            json!({"options":[
-                {"kind":"allow_once"}, {"kind":"reject_always"}
-            ]}),
-        ));
-        state.selected = Some("approval:1".into());
-        state.reduced.pending_approval = Some(json!({"nonce":"secret"}));
-        assert_eq!(
-            state.approval_decision('A'),
-            None,
-            "allow-for-session was not offered"
-        );
-        assert_eq!(
-            state.approval_decision('a'),
-            Some(("secret".into(), StructuredApprovalDecision::AllowOnce))
-        );
-    }
-
-    #[test]
-    fn resolved_approval_ignores_its_late_failure() {
-        let mut state = StructuredState::default();
-        state.rows.push(row(
-            "approval:1",
-            TranscriptRowKind::Approval,
-            json!({"options":[{"kind":"allow_once"}]}),
-        ));
-        state.selected = Some("approval:1".into());
-        state.reduced.pending_approval = Some(json!({"nonce":"old"}));
-        assert!(state.approval_decision('a').is_some());
-
-        state.apply(StructuredEvent::ProjectionUpdate {
-            transcript: None,
-            state: ReducedState::default(),
-        });
-        state.approval_failed("old", "response lost".into());
-
-        assert_eq!(state.error, None);
-        assert!(!state.approval_submitting);
-    }
-
-    #[test]
-    fn superseded_approval_ignores_its_late_failure() {
-        let mut state = StructuredState::default();
-        state.rows.push(row(
-            "approval:1",
-            TranscriptRowKind::Approval,
-            json!({"options":[{"kind":"allow_once"}]}),
-        ));
-        state.selected = Some("approval:1".into());
-        state.reduced.pending_approval = Some(json!({"nonce":"old"}));
-        assert!(state.approval_decision('a').is_some());
-
-        state.rows.push(row(
-            "approval:2",
-            TranscriptRowKind::Approval,
-            json!({"options":[{"kind":"allow_once"}]}),
-        ));
-        state.apply(StructuredEvent::ProjectionUpdate {
-            transcript: None,
-            state: ReducedState {
-                pending_approval: Some(json!({"nonce":"new"})),
-                ..ReducedState::default()
-            },
-        });
-        assert_eq!(
-            state.approval_decision('a'),
-            Some(("new".into(), StructuredApprovalDecision::AllowOnce))
-        );
-
-        state.approval_failed("old", "response lost".into());
-
-        assert_eq!(state.error, None);
-        assert!(state.approval_submitting);
-    }
-
-    #[test]
-    fn matching_approval_surfaces_its_failure() {
-        let mut state = StructuredState::default();
-        state.rows.push(row(
-            "approval:1",
-            TranscriptRowKind::Approval,
-            json!({"options":[{"kind":"allow_once"}]}),
-        ));
-        state.selected = Some("approval:1".into());
-        state.reduced.pending_approval = Some(json!({"nonce":"current"}));
-        assert!(state.approval_decision('a').is_some());
-
-        state.approval_failed("current", "request failed".into());
-
-        assert_eq!(state.error.as_deref(), Some("request failed"));
-        assert!(!state.approval_submitting);
-    }
-
-    #[test]
-    fn composer_is_gated_by_the_projected_turn_lifecycle() {
-        let mut state = StructuredState::default();
-        state.edit_composer(&InputKey::char('h'));
-        state.edit_composer(&InputKey::char('i'));
-        assert_eq!(state.begin_prompt().as_deref(), Some("hi"));
-        assert!(state.turn_active());
-        state.prompt_failed("hi".into(), "nope".into());
-        assert_eq!(state.composer.value(), "hi");
-
-        state.reduced.turn = TurnState {
-            responding: true,
-            ..TurnState::default()
-        };
-        state.edit_composer(&InputKey::char('x'));
-        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();
-        state.edit_composer(&InputKey::char('h'));
-        state.edit_composer(&InputKey::char('i'));
-        assert_eq!(state.begin_prompt().as_deref(), Some("hi"));
-
-        state.apply(StructuredEvent::ProjectionUpdate {
-            transcript: None,
-            state: ReducedState::default(),
-        });
-        assert!(
-            state.turn_active(),
-            "an ordinary idle update must not reopen the composer before turn begin"
-        );
-
-        state.prepare_snapshot_reconciliation();
-        state.apply(StructuredEvent::TranscriptSnapshot {
-            snapshot: TranscriptSnapshot {
-                cursor: 0,
-                rows: Vec::new(),
-            },
-        });
-        state.apply(StructuredEvent::ReducedState {
-            state: ReducedState::default(),
-        });
-        assert!(
-            !state.turn_active(),
-            "a reconnect snapshot must settle a submission whose whole turn was missed"
-        );
-    }
-
-    #[test]
-    fn stale_handshake_state_does_not_settle_a_new_submission() {
-        let mut state = StructuredState::default();
-        state.prepare_snapshot_reconciliation();
-        state.apply(StructuredEvent::TranscriptSnapshot {
-            snapshot: TranscriptSnapshot {
-                cursor: 0,
-                rows: Vec::new(),
-            },
-        });
-
-        state.edit_composer(&InputKey::char('h'));
-        state.edit_composer(&InputKey::char('i'));
-        assert_eq!(state.begin_prompt().as_deref(), Some("hi"));
-        state.apply(StructuredEvent::ReducedState {
-            state: ReducedState::default(),
-        });
-
-        assert!(
-            state.turn_active(),
-            "state captured before this submission must not reopen the composer"
-        );
-    }
-
-    #[test]
-    fn failed_submission_reconciliation_does_not_settle_its_successor() {
-        let mut state = StructuredState::default();
-        state.edit_composer(&InputKey::char('a'));
-        assert_eq!(state.begin_prompt().as_deref(), Some("a"));
-        state.prepare_snapshot_reconciliation();
-
-        state.prompt_failed("a".into(), "nope".into());
-        state.composer = TextInput::with_value("b");
-        assert_eq!(state.begin_prompt().as_deref(), Some("b"));
-
-        state.apply(StructuredEvent::TranscriptSnapshot {
-            snapshot: TranscriptSnapshot {
-                cursor: 0,
-                rows: Vec::new(),
-            },
-        });
-        state.apply(StructuredEvent::ReducedState {
-            state: ReducedState::default(),
-        });
-
-        assert!(
-            state.turn_active(),
-            "a reconnect for the failed submission must not settle its successor"
-        );
-    }
-}

crates/maestro-tui/tests/structured_http.rs

@@ -1,79 +0,0 @@
-//! The TUI's structured actions use the shared typed daemon client; assert the
-//! exact route and bare approval decision body at the HTTP boundary.
-
-use std::sync::{Arc, Mutex};
-
-use axum::extract::{Path, State};
-use axum::routing::post;
-use axum::{Json, Router};
-use maestro_protocol::{DaemonClient, StructuredApprovalDecision, StructuredPromptRequest};
-use uuid::Uuid;
-
-#[derive(Debug, Default)]
-struct Seen {
-    prompt: Option<String>,
-    cancelled: bool,
-    approval: Option<(String, StructuredApprovalDecision)>,
-}
-
-type Shared = Arc<Mutex<Seen>>;
-
-async fn prompt(
-    State(seen): State<Shared>,
-    Path(_id): Path<Uuid>,
-    Json(body): Json<StructuredPromptRequest>,
-) {
-    seen.lock().unwrap().prompt = Some(body.prompt);
-}
-
-async fn cancel(State(seen): State<Shared>, Path(_id): Path<Uuid>) {
-    seen.lock().unwrap().cancelled = true;
-}
-
-async fn approval(
-    State(seen): State<Shared>,
-    Path((_id, nonce)): Path<(Uuid, String)>,
-    Json(decision): Json<StructuredApprovalDecision>,
-) {
-    seen.lock().unwrap().approval = Some((nonce, decision));
-}
-
-#[tokio::test(flavor = "multi_thread")]
-async fn prompt_cancel_and_approval_use_structured_api_contract() {
-    let seen = Shared::default();
-    let app = Router::new()
-        .route("/api/sessions/:id/structured/prompt", post(prompt))
-        .route("/api/sessions/:id/structured/cancel", post(cancel))
-        .route(
-            "/api/sessions/:id/structured/approvals/:nonce",
-            post(approval),
-        )
-        .with_state(seen.clone());
-    let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
-    let addr = listener.local_addr().unwrap();
-    tokio::spawn(async move { axum::serve(listener, app).await.unwrap() });
-
-    let client = DaemonClient::new(format!("http://{addr}"));
-    let id = Uuid::from_u128(141);
-    client.send_structured_prompt(id, "ship it").await.unwrap();
-    client.cancel_structured_turn(id).await.unwrap();
-    client
-        .resolve_structured_approval(
-            id,
-            "one-use-nonce",
-            StructuredApprovalDecision::AllowForSession,
-        )
-        .await
-        .unwrap();
-
-    let seen = seen.lock().unwrap();
-    assert_eq!(seen.prompt.as_deref(), Some("ship it"));
-    assert!(seen.cancelled);
-    assert_eq!(
-        seen.approval,
-        Some((
-            "one-use-nonce".into(),
-            StructuredApprovalDecision::AllowForSession
-        ))
-    );
-}

crates/maestro-tui/tests/structured_task_ws.rs

@@ -1,107 +0,0 @@
-//! Projection socket coverage: snapshots replace state on reconnect and live
-//! deltas patch rows without client-side event folding.
-
-use std::sync::atomic::{AtomicUsize, Ordering};
-use std::sync::Arc;
-use std::time::Duration;
-
-use axum::extract::ws::{Message, WebSocketUpgrade};
-use axum::extract::State;
-use axum::response::Response;
-use axum::routing::any;
-use axum::Router;
-use maestro_protocol::{
-    ReducedState, StructuredEvent, TranscriptDelta, TranscriptRow, TranscriptRowKind,
-    TranscriptSnapshot,
-};
-use maestro_tui::session_task::SessionState;
-use maestro_tui::structured_task::StructuredTask;
-use serde_json::json;
-
-async fn structured_handler(
-    State(connects): State<Arc<AtomicUsize>>,
-    ws: WebSocketUpgrade,
-) -> Response {
-    ws.on_upgrade(move |mut socket| async move {
-        let attempt = connects.fetch_add(1, Ordering::SeqCst);
-        let snapshot = if attempt == 0 {
-            TranscriptSnapshot {
-                cursor: 1,
-                rows: vec![row("old", json!({"content":{"type":"text","text":"old"}}))],
-            }
-        } else {
-            TranscriptSnapshot {
-                cursor: 3,
-                rows: vec![row("live", json!({"content":{"type":"text","text":"one"}}))],
-            }
-        };
-        send(
-            &mut socket,
-            StructuredEvent::TranscriptSnapshot { snapshot },
-        )
-        .await;
-        if attempt == 0 {
-            let _ = socket.close().await;
-            return;
-        }
-        send(
-            &mut socket,
-            StructuredEvent::ProjectionUpdate {
-                transcript: Some(TranscriptDelta::Patch {
-                    row: row("live", json!({"content":{"type":"text","text":"two"}})),
-                }),
-                state: ReducedState {
-                    model: Some("test-model".into()),
-                    ..ReducedState::default()
-                },
-            },
-        )
-        .await;
-        tokio::time::sleep(Duration::from_secs(3)).await;
-    })
-}
-
-fn row(id: &str, data: serde_json::Value) -> TranscriptRow {
-    TranscriptRow {
-        id: id.into(),
-        kind: TranscriptRowKind::AgentText,
-        data,
-    }
-}
-
-async fn send(socket: &mut axum::extract::ws::WebSocket, event: StructuredEvent) {
-    socket
-        .send(Message::Text(serde_json::to_string(&event).unwrap()))
-        .await
-        .unwrap();
-}
-
-#[tokio::test(flavor = "multi_thread")]
-async fn reconnect_snapshot_replaces_then_delta_patches_projection() {
-    let connects = Arc::new(AtomicUsize::new(0));
-    let app = Router::new()
-        .route("/api/structured/x", any(structured_handler))
-        .with_state(connects.clone());
-    let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
-    let addr = listener.local_addr().unwrap();
-    tokio::spawn(async move { axum::serve(listener, app).await.unwrap() });
-
-    let handle = StructuredTask::spawn(format!("ws://{addr}/api/structured/x"));
-    for _ in 0..250 {
-        tokio::time::sleep(Duration::from_millis(10)).await;
-        let state = handle.state.lock().unwrap().clone();
-        if state.reduced.model.as_deref() == Some("test-model") {
-            assert_eq!(state.rows.len(), 1);
-            assert_eq!(state.rows[0].id, "live");
-            assert_eq!(state.rows[0].data["content"]["text"], "two");
-            assert!(connects.load(Ordering::SeqCst) >= 2);
-            handle.end();
-            assert_eq!(handle.connection(), SessionState::Ended);
-            return;
-        }
-    }
-    panic!(
-        "structured projection never reached reconnect delta; connection={:?}",
-        handle.connection()
-    );
-}

crates/maestro/Cargo.toml

@@ -29,6 +29,3 @@ tracing-subscriber.workspace = true
 maestro-cli = { path = "../maestro-cli", optional = true, default-features = false }
 maestro-daemon = { path = "../maestro-daemon", optional = true, default-features = false }
 maestro-tui = { path = "../maestro-tui", optional = true }
-
-[dev-dependencies]
-tempfile.workspace = true

crates/maestro/tests/subcommand_routing.rs

@@ -1,102 +0,0 @@
-//! Process-level routing for the umbrella `maestro` binary (#10): each
-//! enabled top-level subcommand must reach its own crate's runtime dispatch,
-//! not just parse successfully.
-//!
-//! A malformed `--config` file makes every crate's dispatch fail identically
-//! at config load, before any subcommand touches tmux, the network, or a
-//! terminal. That lets the assertions tell "clap parsed it but the handler
-//! never ran" (a usage error, exit 2) apart from "it dispatched into the real
-//! crate" (a `toml decode` runtime error via `main`'s `maestro: {e}` printer,
-//! exit 1).
-//!
-//! The absence tests below only compile when the matching feature is off, so
-//! they run under CI's per-feature-subset matrix (`--no-default-features
-//! --features cli|daemon|tui`) rather than the default all-features build.
-
-use std::io::Write;
-use std::path::PathBuf;
-use std::process::{Command, Output};
-
-fn bin() -> PathBuf {
-    PathBuf::from(env!("CARGO_BIN_EXE_maestro"))
-}
-
-fn bad_config() -> tempfile::NamedTempFile {
-    let mut f = tempfile::NamedTempFile::new().expect("create temp config file");
-    write!(f, "this is not valid toml {{{{{{").expect("write temp config");
-    f
-}
-
-fn run(args: &[&str]) -> Output {
-    Command::new(bin())
-        .args(args)
-        .output()
-        .unwrap_or_else(|e| panic!("spawn `maestro {args:?}`: {e}"))
-}
-
-/// Real dispatch happened: exit 1, `main`'s `"maestro: {e}"` prefix, and the
-/// config crate's error surfacing through — never clap's own usage-error
-/// page, which would mean the subcommand never reached its handler.
-fn assert_dispatched(out: &Output) {
-    let stderr = String::from_utf8_lossy(&out.stderr);
-    assert_eq!(out.status.code(), Some(1), "stderr:\n{stderr}");
-    assert!(stderr.starts_with("maestro: "), "stderr:\n{stderr}");
-    assert!(stderr.contains("toml decode"), "stderr:\n{stderr}");
-    assert!(!stderr.contains("Usage:"), "stderr:\n{stderr}");
-}
-
-/// Never reached a handler: clap rejected the subcommand outright because the
-/// feature that defines it is off. Only used by the `not(feature = "...")`
-/// tests below, which themselves only exist in a single-feature build.
-#[cfg(not(all(feature = "cli", feature = "daemon", feature = "tui")))]
-fn assert_unrecognized(out: &Output, name: &str) {
-    let stderr = String::from_utf8_lossy(&out.stderr);
-    assert_eq!(out.status.code(), Some(2), "stderr:\n{stderr}");
-    assert!(
-        stderr.contains("unrecognized subcommand"),
-        "stderr:\n{stderr}"
-    );
-    assert!(stderr.contains(name), "stderr:\n{stderr}");
-}
-
-#[cfg(feature = "cli")]
-#[test]
-fn list_dispatches_into_maestro_cli() {
-    let cfg = bad_config();
-    let out = run(&["list", "--config", cfg.path().to_str().unwrap()]);
-    assert_dispatched(&out);
-}
-
-#[cfg(not(feature = "cli"))]
-#[test]
-fn list_is_unrecognized_without_cli_feature() {
-    assert_unrecognized(&run(&["list"]), "list");
-}
-
-#[cfg(feature = "daemon")]
-#[test]
-fn daemon_dispatches_into_maestro_daemon() {
-    let cfg = bad_config();
-    let out = run(&["daemon", "--config", cfg.path().to_str().unwrap()]);
-    assert_dispatched(&out);
-}
-
-#[cfg(not(feature = "daemon"))]
-#[test]
-fn daemon_is_unrecognized_without_daemon_feature() {
-    assert_unrecognized(&run(&["daemon"]), "daemon");
-}
-
-#[cfg(feature = "tui")]
-#[test]
-fn tui_dispatches_into_maestro_tui() {
-    let cfg = bad_config();
-    let out = run(&["tui", "--config", cfg.path().to_str().unwrap()]);
-    assert_dispatched(&out);
-}
-
-#[cfg(not(feature = "tui"))]
-#[test]
-fn tui_is_unrecognized_without_tui_feature() {
-    assert_unrecognized(&run(&["tui"]), "tui");
-}

docs/COMMAND-BAR.md

@@ -123,9 +123,9 @@ client opening `/api/attach/:id`, and a client reporting focus explicitly at
 `POST /api/sessions/:id/focus` when it refocuses a pane that is already open.
 
 **A session that has never been focused sorts after every session that has**,
-and among those, most recently created first. Dead sessions sort after live
-ones regardless of recency: a session you cannot attach to is not where you
-just were.
+and among those, most recently created first. Sessions with no live pane —
+`Dead`, and `Dormant` (#162) — sort after live ones regardless of recency: a
+session you cannot attach to is not where you just were.
 
 Under `>` an empty query lists every command in registry order. Under `~` it
 lists recent dirs, most recent first, then the project list.

docs/INSTALL.md

@@ -18,14 +18,10 @@ wizard, and cleans up — only the unified `maestro` binary ends up persisted in
 
 **Updating is the same command.** Re-running `./install.sh` detects an existing
 systemd unit, refreshes it, and runs `systemctl --user restart maestro` instead
-of `start`. No `--update` flag needed. **The restart keeps your terminal sessions:** the unit sets
+of `start`. No `--update` flag needed. **The restart keeps your sessions:** the unit sets
 `KillMode=process`, so systemd signals only the daemon — the tmux server (and
-every tmux-backed session) survives, and the new daemon re-adopts them on
-start. Structured sessions (an agent run as a daemon child over ACP) are not
-tmux panes, so shutdown ends their active turn; the transcript survives and
-the next daemon attempts one resume (`docs/RESTART.md#structured-sessions`). A
-unit written before this default lacks the line; re-run `./install.sh` to
-refresh it.
+every session) survives, and the new daemon re-adopts them on start. A unit
+written before this default lacks the line; re-run `./install.sh` to refresh it.
 
 Inside the script, `cargo install --git https://git.naps.pt/naps62/maestro …`
 uses your already-configured git credentials for this host (HTTPS helper or
@@ -98,10 +94,7 @@ running a local daemon, for a host that only talks to another machine's.
 
 The daemon unit carries the same `KillMode=process` as the wizard-written one,
 so `systemctl --user restart maestro-daemon` leaves the tmux server and every
-terminal session alive. Structured sessions end their active turn on
-shutdown and resume once on the next daemon: ACP state comes back via
-`session/load`, while the event log only replays Maestro's own transcript
-projection (`docs/RESTART.md#structured-sessions`).
+session alive.
 
 ## Thin builds for single-role hosts
 
@@ -195,37 +188,6 @@ An unknown name is rejected as an `[tui].theme` configuration error.
 The full action vocabulary is the `Action` enum in
 `crates/maestro-tui/src/action.rs`.
 
-## Structured sessions: ACP adapters
-
-A session spawned with `view: Structured` runs Claude Code or Codex as a child
-of the daemon over the Agent Client Protocol instead of in a tmux pane. The
-resolved session command selects the adapter binary, which must be on the
-session's `PATH` when the spawn request sets one, or the daemon's `PATH`
-otherwise. Install the adapter for each provider you use:
-
-```sh
-npm install -g --prefix ~/.local @zed-industries/claude-code-acp
-npm install -g --prefix ~/.local @agentclientprotocol/codex-acp
-```
-
-That puts `claude-code-acp` and `codex-acp` in `~/.local/bin`, which must be on
-the applicable `PATH` (a systemd user unit does not read your shell profile; set
-`Environment=PATH=…` in the unit or install somewhere already on it). The
-Claude adapter needs a logged-in Claude Code (`claude /login`); Codex uses the
-Codex CLI's or adapter's configured authentication.
-
-When the adapter is missing the spawn still creates the session, marked dead
-with the provider-specific install command as its activity detail, so clients
-say what to run. The adapter is a child of the daemon: it ends with a `DELETE
-/api/sessions/:id` (`session/cancel`, then `SIGTERM`) and with the daemon
-itself. A daemon restart ends an in-flight structured turn, but preserves its
-worktree, session record, and event-log transcript. The replacement daemon
-starts a new adapter, resumes it with `session/load`, and replays the
-transcript. Terminal sessions keep surviving restarts through tmux. See
-`docs/STRUCTURED-VIEW.md` for the full contract — row kinds, projections, the
-handshake, and the approval and recovery rules — and `docs/RESTART.md` for
-what a client observes across the restart.
-
 ## The browser UI
 
 The daemon serves the SPA off its own listener. Open
@@ -281,6 +243,26 @@ Pick `/tmp` if the daemon must outlive your login session and you can't run
 tmux sockets with it). The env var `MAESTRO_DAEMON_TMUX_TMPDIR` takes
 precedence over the file.
 
+## What happens to sessions after a reboot
+
+A host reboot kills the tmux server, so every session the daemon knew is dead
+while its record on disk survives. What recovery does with those is
+`[daemon].resume_on_boot`:
+
+```toml
+[daemon]
+resume_on_boot = "dormant"   # "dormant" (default) | "auto" | "never"
+```
+
+- `dormant` — the sessions are listed but not running, and you resume the ones
+  you want from the web UI or the TUI.
+- `auto` — the daemon resumes them all itself during startup. Only pick this
+  on a host where restarting every agent unattended is safe: they come back on
+  the flags they were spawned with, with nobody watching.
+- `never` — the records are deleted and a reboot is a clean slate.
+
+See `docs/RESTART.md` for the full contract.
+
 ## What the systemd unit looks like
 
 The wizard writes a *user* unit (`systemctl --user`), since `maestro daemon`

docs/PREVIEW.md

@@ -28,6 +28,12 @@ A preview is a view, not a state. Nothing about it is durable:
 | Already in a pane, in another tab | That tab is brought forward. The active tab is restored when the preview ends. |
 | Not in any pane | A throwaway tab carries it. It is removed when the preview ends. |
 
+A session that is not `Running` — a dormant one, most often — never gets a
+live attach here or anywhere else a pane is filled: the daemon has nothing to
+answer a `409 not_attachable` and the socket would just die (WS close 1006).
+Its pane shows the same metadata-and-resume view `docs/SIDEBAR.md` describes
+for its card, honest about the fact that there is nothing to preview yet.
+
 The throwaway tab never counts as an open session: the tab bar does not appear
 because of it, the mobile shell does not switch away from the session list for
 it, and the sidebar does not mark the session as open.

docs/RESTART.md

@@ -2,16 +2,10 @@
 
 Maestro is upgraded in place: the operator reinstalls the binary and systemd
 restarts the daemon under every browser tab and TUI that is attached to it.
-tmux keeps **terminal** sessions alive across that (see `docs/INSTALL.md`),
-but clients lose their sockets either way. This document is the contract for
-what a client does about it — what the daemon publishes, how a client tells a
-restart from a blip, and what the user sees while it happens.
-
-A **structured** session (`docs/STRUCTURED-VIEW.md`) has no tmux pane behind
-it to survive on: its agent is a child of the daemon process itself, so a
-restart takes it down with the daemon. See
-[Structured sessions](#structured-sessions) below for exactly what that
-costs and what it doesn't.
+tmux keeps the sessions alive across that (see `docs/INSTALL.md`), but clients
+lose their sockets. This document is the contract for what a client does about
+it — what the daemon publishes, how a client tells a restart from a blip, and
+what the user sees while it happens.
 
 ## What the daemon publishes
 
@@ -74,34 +68,115 @@ resolves, so a blocked client is never a trapped one. It clears itself the
 moment a probe succeeds — there is no "retry" button, because the client is
 already retrying.
 
-## Structured sessions
+## What survives, and what comes back dormant
 
-Everything above describes a **client's** view of a restart, and it holds for
-a structured session exactly as written — the same three verdicts, the same
-status indicator, the same overlay. What differs is what survives on the
-**daemon** side, because a structured session's agent is a daemon child, not
-a tmux pane:
+A daemon restart leaves tmux alone, so recovery re-adopts every
+`maestro-<uuid>` session tmux still holds and the operator sees no change
+beyond the reconnect above.
 
-- A restart **ends the active turn**. There is no adapter process left to
-  finish it, and no tmux pane keeping it alive underneath.
-- The **transcript survives**, in the per-session event log
-  (`docs/STRUCTURED-VIEW.md#persistence-recovery-and-dead-sessions`) — a
-  graceful shutdown marks the session for one resume attempt. Recovery is
-  two separate operations, not one: the next daemon calls `session/load` so
-  the adapter restores its own ACP session, but whatever history the
-  adapter emits during that call is discarded, not replayed into anything —
-  the daemon already has that history on disk. Separately, the daemon
-  rebuilds its own projection by folding the persisted event log back
-  through it. An ungraceful death (a crash, `kill -9`) leaves no resume
-  marker, and the session stays dead permanently.
-- **Pending approvals and their nonces do not survive.** Both live only in
-  the old daemon's memory; any ACP permission request still mid-flight when
-  the daemon exits is answered `Cancelled` on the way down, and a resumed
-  session starts with no pending approval at all.
+A **host reboot** is different: it kills the tmux server, so there is nothing
+to adopt while every session's sidecar is still on disk. Recovery always asks
+tmux — `tmux list-sessions` is the single source of truth for liveness, and the
+kernel's `boot_id` only tells a reboot from a restart in the log (#164, #174).
+A boot id changes without the tmux server dying whenever the state directory is
+restored, a VM or container snapshot is rolled back, or the `boot_id` file is
+truncated; a session tmux still holds is adopted `Running` in every one of
+those cases. Recovery makes a
+second pass over those sidecars and registers each as a `Dormant` session
+(#162) — id, name, cwd, command, worktree and `created_at` intact. A dormant
+session has no pane and no PTY bridge: it cannot be attached to, typed into or
+resized, and neither watcher pass touches it.
 
-`docs/STRUCTURED-VIEW.md` is the full contract for all of this — the event
-log's shape, the recovery marker, and exactly which kind of session death is
-resumable.
+A dormant session is brought back with `POST /api/sessions/:id/resume` (#166),
+which respawns tmux under the **same** uuid and sidecar — `metadata.name`,
+`created_at`, `env` and worktree ownership all survive, and only the tmux
+session and the PTY bridge are new. The command is the matching spawn preset's
+`resume_command` with `{agent_session}` filled in from the session's own
+`agent_session_id`, so an agent comes back inside its old conversation; a
+session with no matching preset, no `resume_command`, or no reported
+conversation id is respawned on the command it was created with. `Session::command`
+always keeps that original command, so a second resume resolves the same preset.
+Resume is refused with `409` for a session that is already running
+(`already_running`) and for one whose `cwd` has disappeared (`cwd_missing`) —
+neither is something a respawn could fix. A session with a resume already in
+flight is refused as `already_running` too (#175): the respawn happens with
+the session map unlocked, so the record is marked in-flight before it starts
+and the second request is answered on that state rather than on its tmux spawn
+colliding with the first one's. A resume that loses a race with a kill takes
+its own sidecar back off disk, so the killed session does not return as a
+dormant ghost on the next recovery. The other thing to do with a dormant
+session is dismiss it, which removes the sidecar so the next recovery does not
+bring it back.
+
+## What the pane looks like when it comes back
+
+The PTY replay ring lives in memory, so a resumed session would otherwise open
+on a blank pane: the conversation is back, the terminal history the operator
+was reading is not. Each bridge's ring is mirrored to
+`<state_dir>/scrollback/<id>.bin` (#171) and handed to the new bridge on
+resume, and on the recovery pass that re-adopts a session tmux still holds —
+that one lost its ring with the previous daemon too. The restored bytes go out
+ahead of the live ones, and are dropped once the ring holds a full budget of
+new output of its own, which is the point where everything restored is older
+than the budget covers.
+
+The file is capped at the same `[daemon] pty_replay_bytes` budget the ring
+uses — one budget, not two — and it is deleted when the session is killed, and
+when recovery prunes its sidecar. Nothing here can fail a resume: a missing,
+unreadable or oversized file degrades to an empty pane, which is exactly what
+the operator had before it existed.
+
+It is flushed every 10 seconds by the liveness watcher, and once more when a
+session's bridge is sealed on exit. The timer is the part that matters: a host
+reboot runs no exit path at all, so scrollback written only on a clean shutdown
+would be missing in the one case this exists for. Ten seconds bounds the loss
+to the last few lines — scrollback is visual continuity, not state — and costs
+at most one file write per *active* session per tick, since a session whose
+bridge has read nothing since the last flush is skipped.
+
+## What recovery does with them: `resume_on_boot`
+
+Whether a recovered-but-dead session is left dormant at all is the operator's
+call, per host, via `[daemon].resume_on_boot` (#167):
+
+| value       | what recovery does                                                    |
+| ----------- | --------------------------------------------------------------------- |
+| `"dormant"` | **Default.** Register each one dormant and wait for the operator.      |
+| `"auto"`    | Resume each one during recovery, itself.                               |
+| `"never"`   | Prune the sidecars instead — a reboot is a clean slate.                |
+
+`dormant` is the default because resuming agents unattended is a foot-gun:
+they come back on whatever flags they were spawned with, seconds after a
+reboot, with nobody watching. `auto` exists for hosts where that is known to
+be safe, and it is opted into rather than inherited.
+
+`auto` calls the same `resume` the client's `POST /api/sessions/:id/resume`
+does — same uuid, same sidecar, the preset's `resume_command` — so there is
+one resume path and not two. A session that fails to resume is logged and
+stays dormant; the rest still come back.
+
+`never` prunes the same way #163 does for a missing `cwd`: the sidecar is
+deleted and nothing is registered, so the session is not listed and the next
+recovery does not find it. Whatever worktree it owned is left on disk.
+
+The policy only decides the fate of sessions with no live pane. A session
+tmux still holds is adopted `Running` by the first pass under every policy,
+including `never`.
+
+Recovery logs the policy that ran and the number of sessions it acted on, so
+a host that resumes agents unattended says so in its own journal.
+
+Attaching to a session that has no bridge answers `409 not_attachable`, not
+`404 unknown_session`: the session exists, and a client that cannot tell "gone"
+from "not running" cannot offer the resume.
+
+`SessionStatus` is a wire type, so from this build forward it deserializes
+leniently on both clients: a spelling the client does not know reads as `Dead`
+rather than failing the whole session. That leniency lives in the client's own
+binary, so it covers spellings added *after* this build, not this one — a CLI
+or TUI still running an older build fails to parse a `Dormant` session, and
+with it the whole session list, until it is upgraded. Clients render a dormant session as known-but-not-running —
+see `docs/SIDEBAR.md` for the card and `docs/COMMAND-BAR.md` for how it ranks.
 
 ## Timing
 

docs/SIDEBAR.md

@@ -56,7 +56,7 @@ itself is not.
 Line 2 reads left to right:
 
 ```
-[<duration>] [<detail>] <command> [<diff stat> | exited]
+[<duration>] [<detail>] <command> [<diff stat> | exited | dormant]
 ```
 
 Its minimum content is therefore just the command.
@@ -70,7 +70,7 @@ command. `<duration>` follows in the rail's colour when shown. There is no
 state word and no second badge: the rail exists so the state is still legible
 when a row is dimmed or the terminal renders the duration in the default fg.
 
-In the **web client** the rail is a 7px bar pinned to the row's own left
+In the **web client** the rail is a 5px bar pinned to the row's own left
 edge, square corners, spanning the full card height edge to edge — it
 shifts outward with nesting depth along with the row's own padding, since
 it is positioned relative to the row. It carries motion only for states that
@@ -104,8 +104,41 @@ fragment; it no longer decides whether line 2 exists.
 while an agent-reported state is in force (see Precedence): when the report
 lapses at its TTL or is replaced, the detail goes with it. The detail
 truncates with `…` ahead of the trailing fragments — a long detail never
-pushes `<command>`, `<blocked work>`, or `exited` off the line, and neither
-client ever lets it wrap.
+pushes `<command>`, `<blocked work>`, `exited` or `dormant` off the line, and
+neither client ever lets it wrap.
+
+`dormant` (#162) is the counterpart of `exited` for a session the daemon knows
+only from its sidecar: recovery found no tmux session behind it, so it has no
+pane, no scrollback, and nothing to attach to. It is not an exit — nothing was
+observed ending — so the two fragments never both show. The TUI marks the same
+state on line 1 with `◌`, next to `✗` for exited and `●`/`○` for running.
+
+### Dormant cards (#168)
+
+A dormant card is a muted variant of the normal card (the web client's
+`is-dormant` class, the same muted foreground `exited` already uses): name,
+cwd and last-known age render as usual, but the activity rail carries no
+colour, since recovery resets a dormant session's activity to `Idle` and
+there is nothing running to report otherwise.
+
+The row's right-hand actions swap **spawn similar** for **resume** (↻) — there
+is no live state to clone from — and call `POST /api/sessions/:id/resume`
+(#166). **Kill** stays: it is how a dormant session is dismissed, since the
+daemon already treats a kill of a dormant session as removing its sidecar
+rather than anything it needs to be running to do.
+
+A dormant session takes the **lowest precedence in the ordering**: within a
+folder, every live (`Running` or `Dead`) session sorts before every dormant
+one, name notwithstanding, and dormant sessions sort among themselves by name.
+So a reboot that leaves a whole tree dormant never buries the live work a
+session spawns into it.
+
+Selecting a dormant session — by click, by keyboard, or by preview
+(`docs/PREVIEW.md`) — never opens a live attach: the content pane shows the
+same metadata and resume affordance the card does, rather than a terminal
+that would die on the daemon's `409 not_attachable` (WS close 1006). Resuming
+turns the session `Running`; the pane and the card pick that up on their own
+next update, no navigation required.
 
 `<diff stat>` is the blocked-work breakdown (#83) in diff notation, replacing
 the spelled-out `⚠ 3 uncommitted files, 2 unpushed commits`. It renders only
@@ -160,7 +193,6 @@ The state word is never spelled out — the colour carries it.
 | ---------------- | --------- | ---------------- |
 | `Active`         | `--live`  | `active`         |
 | `Idle`           | `--muted` | `idle`           |
-| `Starting`       | `--muted` | `idle`           |
 | `AwaitingInput`  | `--warn`  | `awaiting`       |
 | `Error`          | `--danger`| `error`          |
 
@@ -210,7 +242,7 @@ the cursor's fill while the pane holds the keyboard, and the web's ring on a
 highlighted **folder** row — a folder previews nothing, so it has no fill to
 step up to.
 
-The duration text inherits its state's colour; the exited and command
+The duration text inherits its state's colour; the exited, dormant and command
 fragments use the surface's `muted` role, as do the diff stat's `~`, `?` and
 `↑` fragments. Only `+` and `-` step outside the surface's muted role, and they
 take the `active` and `error` roles of the same surface.
@@ -232,24 +264,7 @@ cutover points land within one tick.
 
 ## Precedence
 
-### Activity source by session kind
-
-The daemon supplies one `activity` field to both clients, but its source depends
-on the session kind:
-
-| Session kind | Source |
-|---|---|
-| Terminal | The existing agent-report override and five-minute TTL, falling back to PTY quiescence, foreground process and `/proc` input-block inference. |
-| Structured | ACP state directly: a pending approval is `AwaitingInput`; otherwise an in-flight turn is `Active`; no turn is `Idle`. A failed turn or dead structured session is `Error`, and the next turn clears a failed-turn error. |
-
-Structured sessions never enter the terminal inference path and ignore activity
-reports inherited through agent hooks. They have no PTY whose output or blocked
-read could describe their state. This is a second source, not a replacement for
-the terminal source.
-
-### Terminal report override
-
-For terminal sessions, an agent-reported `ActivityState` (#105) overrides the daemon's inference for
+An agent-reported `ActivityState` (#105) overrides the daemon's inference for
 **five minutes** (the TTL is fixed by the daemon; re-reporting extends it).
 When the TTL expires, inference resumes and the session's reported detail —
 if any — clears with the report. Clients never blend the two: whichever source
@@ -268,10 +283,6 @@ Two rulings specific to a reported `Error` (#114):
   process changes do not clear it — only the agent itself may withdraw what
   the agent itself reported. Re-reporting `Error` extends the TTL rather than
   stacking reports.
-- **Only Claude Code reports `Error`.** Codex has no counterpart to
-  `StopFailure` in its hook event set, so a codex turn that ends on an API
-  error reports `AwaitingInput` and its card carries no error mark. A card
-  without the mark means "nothing reported a failure", not "nothing failed".
 
 If a client receives an `ActivityState` variant it does not know, it must not
 fail rendering: treat it as `Idle` (neutral/dim, line-2 rules apply as usual)
@@ -299,10 +310,10 @@ session is genuinely `Active` again — new work, not merely a refocus. Only
 after that fresh `Active` cycle does the *next* `AwaitingInput` glow again.
 Unfocusing and refocusing alone never re-arms it.
 
-This applies uniformly to `AwaitingInput` from terminal inference, an agent
-report (#105), or a structured session's pending approval, since the rail draws
-them identically. It does not touch `Error`; terminal reports keep their TTL,
-while a structured failed-turn error clears when the next turn starts.
+This applies uniformly to `AwaitingInput` from either source — the daemon's
+own inference or an agent's report (#105) — since the rail draws them
+identically. It does not touch `Error`; that state's own TTL (below) is
+unrelated and unaffected by focus.
 
 Each client reports its own pane's focus with `POST /api/sessions/:id/focus`
 (`{"focused": bool}`) whenever the pane it is showing changes — on attach, on
@@ -325,10 +336,9 @@ lands on the first row it was hiding. A highlight parked on a skipped row —
 reachable by clicking a folder header — still steps to its neighbour rather
 than jumping to the end of the list.
 
-The web client needs a chord to reach the list at all (leader-`h` — `Ctrl+A h`
-by default — and the same chord back): an attached terminal owns every plain
-keystroke, and Escape is left to reach the pane's shell/app instead. The TUI
-uses `ctrl-w h`.
+The web client needs a chord to reach the list at all (`Ctrl+Shift+H`, and the
+same chord back): an attached terminal owns every plain keystroke. The TUI uses
+`ctrl-w h`.
 
 Everything else is the same key on both clients:
 

docs/STRUCTURED-VIEW.md

@@ -1,464 +0,0 @@
-# STRUCTURED-VIEW.md — the structured session contract
-
-The contract for a structured session (`view: Structured`, #133): an agent run
-as a daemon child over the Agent Client Protocol (ACP) instead of in a tmux
-pane. Alongside `docs/WORKTREES.md`, `docs/SIDEBAR.md` and `docs/RESTART.md`,
-read this before changing anything that renders a structured session — both
-the web and TUI renderers are written against it.
-
-It covers the eight transcript row kinds, what the daemon decides versus what
-a client decides, the two projections and their delta/cursor semantics, the
-ACP handshake and the capabilities it declines, the adapter's install
-command, and the approval nonce rules. **Non-goal: the detached runner.** It
-does not exist yet, and nothing here describes it.
-
-## What a structured session is
-
-A terminal session's agent runs inside a tmux pane; a structured session's
-agent runs as a subprocess of the daemon itself, speaking ACP over stdio. The
-daemon is the ACP **client**; the provider adapter process is the ACP
-**agent**. It translates the provider's events into ACP `session/update`
-notifications instead of drawing them to a pane. `crates/maestro-acp` owns the
-daemon's side of that connection;
-`crates/maestro-daemon/src/projection.rs` folds what it receives into the two
-projections below.
-
-The child is a real child of the daemon process: same process group, and on
-Linux marked with `PR_SET_PDEATHSIG` so it dies with the daemon even if the
-daemon exits without cleaning up; other platforms have no such signal and
-depend on an orderly shutdown/drop to terminate it. The ordinary path on
-every platform is `AcpSession::terminate` (`session/cancel`, a short grace,
-`SIGTERM`, then `SIGKILL`), called from both `DELETE /api/sessions/:id` and
-daemon shutdown.
-`docs/WORKTREES.md`'s kill-guard rule — an unforced kill refused while the
-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
-resolved by walking the session's `PATH` when the spawn request sets one, or
-the daemon's `PATH` otherwise, and taking the first executable with that name.
-
-| Command | Adapter binary | Install command | Provider detail |
-| --- | --- | --- | --- |
-| `claude` | `claude-code-acp` | `npm install -g --prefix ~/.local @zed-industries/claude-code-acp` | Needs a logged-in Claude Code. |
-| `codex` | `codex-acp` | `npm install -g --prefix ~/.local @agentclientprotocol/codex-acp` | Uses Codex CLI or adapter-configured authentication; it advertises model, reasoning-effort, agent-mode, and optional fast-mode configuration. |
-
-The selected install command is baked into `AcpError::AdapterMissing`. When an
-adapter cannot be found, spawn still creates a **Dead** session with that
-command as `activity_detail` (see `docs/INSTALL.md` for the systemd `PATH`
-caveat). Provider authentication failures surface through the adapter's stderr
-tail in the same field.
-
-The handshake is bounded by `HANDSHAKE_TIMEOUT` (60s) — long enough for a
-slow machine to boot an adapter and its provider process, never long enough
-to hang a spawn indefinitely. Any handshake failure — missing adapter, early
-exit, a protocol error, or the timeout — leaves no orphaned process: `spawn`
-closes and reaps the child itself before returning the error.
-
-## The ACP handshake
-
-`initialize` is where the daemon states what kind of client it is. It
-declares, deliberately, almost nothing:
-
-| Capability | Declared | Why |
-| --- | --- | --- |
-| `fs.readTextFile` | `false` | Providers read the session workspace through their own tool surface. |
-| `fs.writeTextFile` | `false` | Providers write the session workspace through their own tool surface. |
-| `terminal` | `false` | Providers run commands through their own tool surface. |
-
-Declining all three keeps the daemon out of the file/terminal surface
-entirely — the adapter already has direct access to the session's `cwd`, and
-routing every read, write, and shell command through the daemon would only
-add a hop with no new capability. Every other capability namespace ACP
-defines (session extensions, auth, elicitation) is simply left at its
-default; the daemon does not advertise support because neither supported
-adapter needs it, not because it was weighed and refused.
-
-The one client method that *is* implemented for real is
-`session/request_permission` (#139) — see [Approvals](#approvals) below.
-Before #139 it was a stub that declined every request; that stub is gone now
-that a live implementation exists.
-
-`session/new` opens a fresh ACP session on every ordinary spawn. A respawn
-after a daemon restart instead sets `SpawnConfig::load_session(id)` and runs
-`session/load` with the ACP session id the original handshake returned
-(`Session::acp_session_id` on the wire) — the adapter must advertise
-`agent_capabilities.load_session`, or the handshake fails outright naming
-that. Whatever history the adapter streams back while `session/load` is in
-flight is dropped on arrival, deliberately: the daemon's own event log
-already holds that history, and forwarding it too would duplicate every row
-in the projections below.
-
-Codex and Claude differ in what they emit, not in this lifecycle. Codex maps
-shell commands, file changes, MCP calls, web search, image generation/view,
-reasoning, plans, and token usage into standard ACP chunks and tool calls;
-those fold into the same eight rows. Codex's `available_commands_update` and
-`session_info_update`, like equivalent Claude updates, remain opaque
-`Notice` rows. Its `session/load` capability is required for daemon recovery
-just as it is for Claude.
-
-## The eight transcript row kinds
-
-`TranscriptRowKind` (`maestro-protocol`) is the alphabet a structured
-transcript is written in. Every row has a stable `id` (so later deltas can
-address it), a `kind`, and a `data: Value` that preserves the underlying ACP
-payload — clients depend on ACP's *shape* without depending on ACP as a
-crate.
-
-| Kind | Carries | Row identity |
-| --- | --- | --- |
-| `User` | The prompt accepted by Maestro's structured prompt endpoint, persisted before ACP dispatch. An adapter `user_message_chunk` is also supported for imported ACP history. | `user:<uuid>` for a daemon-recorded prompt; `user:<message_id>` or `user:<seq>` for an ACP chunk. |
-| `AgentText` | An `agent_message_chunk` — the agent's visible reply, streamed. | `agent:<message_id>`, or `agent:<seq>` from the first chunk when no id is supplied. Later chunks for the same id—or consecutive anonymous text chunks—are appended into `data.content.text` in place. An empty anonymous chunk starts a fresh row, matching the turn marker emitted by adapters that omit message ids. |
-| `AgentThought` | An `agent_thought_chunk` — the model's reasoning stream. | `thought:<message_id>` / first anonymous `thought:<seq>`, coalesced the same way as `AgentText`. |
-| `ToolCall` | A `tool_call` / `tool_call_update` pair whose content carries no diff. | `tool:<tool_call_id>` — one row for the call's whole life; updates patch it in place, they never create a second row. |
-| `ToolDiff` | The same tool-call machinery, when the tool's content includes a `Diff` block. | Same `tool:<tool_call_id>` identity as `ToolCall`; the *kind* flips between the two as the tool's own content changes, not the row. |
-| `Approval` | A daemon-originated permission request (`RequestPermissionRequest`), serialized without its nonce. | `approval:<uuid>` — minted fresh per request, unrelated to the ACP request's own id. |
-| `Plan` | A `plan` update — the agent's current step list. | The fixed id `"plan"`. Each new plan **replaces** the row wholesale; entries are not diffed against the previous plan. |
-| `Notice` | The raw JSON of any `session/update` variant the ACP dependency already decodes but the projection does not special-case. Maestro also uses a tagged `maestroTurnMeta` notice as the durable footer for a completed, cancelled, or failed turn. | `notice:<seq>` for ACP updates; `turn_meta:<uuid>` for a turn footer. |
-
-`Notice` covers known-but-unspecialized `SessionUpdate` variants: ones the
-`agent-client-protocol` dependency's schema already deserializes (it
-currently folds `available_commands_update` and `session_info_update`
-there) but the projection's `match` doesn't fold into one of the other
-seven kinds. It is not a wire-level forward-compatibility seam:
-`SessionUpdate` is an internally-tagged enum with no unknown-variant
-fallback, so a `session/update` whose `sessionUpdate` tag this build's
-dependency has never heard of — including a variant gated behind an
-unstable ACP feature this build doesn't enable, which is compiled out of
-the enum entirely — fails to deserialize before the projection ever runs,
-rather than becoming a `Notice`. A genuinely new ACP variant needs the
-`agent-client-protocol` dependency upgraded (and, typically, the projection's
-`match` taught about it) before it can appear on this transcript at all — see
-`projection.rs`'s test asserting that an unrecognised `sessionUpdate` tag is a
-deserialization error, not a `Notice`. A client that does not know what to do
-with a `Notice` can still render it as an opaque, collapsed line — that
-remains a reasonable floor, not a client bug.
-
-Rendering is entirely a client concern. The projection's job stops at
-folding ACP into these eight shapes; markdown formatting, diff rendering,
-tool-card treatment, and how a `Notice` is presented are all renderer
-choices, not daemon ones.
-
-## Daemon decisions vs. client decisions
-
-**The daemon decides:**
-
-- Which ACP `session/update` becomes which row kind, and under what id — the
-  fold in `projection.rs` is the one place this logic lives, so the web and
-  TUI renderers can never disagree about it.
-- Turn lifecycle: when a turn begins, and whether an ACP response, a cancel,
-  or a failure ends it (`TurnState.responding` / `.thinking` /
-  `.active_tool_calls` / `.started_at` are derived, not renderer-computed).
-  Ending a turn appends a durable `maestroTurnMeta` footer with its elapsed
-  time, outcome, model, and context-window usage/delta. ACP does not expose
-  provider billing-token counts, so these are explicitly context tokens.
-- Approval nonce minting, secrecy, and the single-active-approval rule (see
-  below) — a client never sees an ACP permission request before the daemon
-  has already turned it into an `Approval` row and a nonce.
-- What happens to an ACP update variant the dependency decodes but nobody has
-  taught the projection to special-case (falls back to `Notice` rather than
-  erroring). A variant the dependency itself can't decode is a deserialization
-  error, not a `Notice` — see [The eight transcript row
-  kinds](#the-eight-transcript-row-kinds).
-- Persistence and replay: what is written to the event log, in what order,
-  and how a restart resumes it.
-
-**A client decides:**
-
-- How each row kind is drawn — markdown for `AgentText`/`AgentThought`, a
-  diff view for `ToolDiff`, a tool card for `ToolCall`, and a floor
-  presentation for `Notice`. `Plan` is the exception: both clients omit it
-  from the transcript; the TUI may show the current plan in its status line,
-  while the web client deliberately has no stats or plan rail.
-- The web client groups each contiguous run of two or more tool rows into a
-  collapsed activity block. An `AgentText` or `AgentThought` row between
-  tools splits them into separate groups, so the timeline reads
-  text → group → text → group rather than lumping every tool in a turn into
-  one box. Text and thought rows stay outside groups as standalone transcript
-  items — the operator sees all reasoning without expanding. Resolved
-  approval rows between tools within a run are absorbed into the group. The
-  collapsed header reads "N tool calls · Label 'arg'" where the label and
-  argument come from the last tool row's `splitToolTitle` — the operator
-  sees which command is current at a glance. Opening the group reveals tool
-  rows in chronological order.
-- The web client's user, agent, thought, tool-detail, and notice text blocks
-  copy their complete source text when clicked or keyboard-activated.
-- The web client consumes `available_commands_update` notices as the live
-  source for composer `/` autocomplete at any whitespace-delimited token under
-  the caret. Completing a command replaces only that token. The client omits
-  those state-only notices, along with `session_info_update`, from the visible
-  transcript.
-- How live `responding`, `thinking`, tool activity, elapsed time, and context
-  usage are drawn. The web client keeps these in a compact strip above the
-  composer and renders each durable turn footer inline with the transcript.
-- How the operator is asked to resolve an `Approval` row — the daemon only
-  exposes the three-way decision (`AllowOnce` / `AllowForSession` / `Deny`),
-  never the UI that solicits it.
-- Scrolling, collapsing, and every other presentation-only behaviour.
-
-## The two projections
-
-`Projection` (daemon-only) is folded once from the durable ACP stream and
-exposes two independent views, both defined in `maestro-protocol`:
-
-- **`TranscriptSnapshot { cursor, rows }`** — the complete ordered list of
-  transcript rows built so far, plus the log position (`cursor`) it reflects.
-  It is intentionally always the *whole* transcript, not a windowed one: a
-  tool row patched much later must still find its original entry.
-- **`ReducedState`** — one whole-session snapshot folded over every event
-  seen: `turn` (the per-turn indicators above), `pending_approval`, `plan`,
-  `usage`/`context`, `model`, and `mode`. Like `TranscriptSnapshot`, it is
-  always full-history, never a delta — a client that only wants "is a turn
-  active right now" never has to replay anything to answer that.
-
-Changes to the transcript travel as `TranscriptDelta`, tagged `type`:
-`Append { row }` (a new row), `Patch { row }` (an existing row, addressed by
-`id`, replaced wholesale), and `Remove { id }`. `Remove` is defined on the
-wire for forward compatibility; nothing in the current projection emits it —
-every row, once appended, is only ever patched or left alone.
-
-### Cursor and replay semantics
-
-The event log's own line position is the cursor: 1-based, shared by ACP
-notifications and daemon-generated rows alike (`sidecar.rs`'s
-`PersistedEvent` envelope is what lets `User` and `Approval` rows share a cursor
-sequence with raw ACP JSON without pretending to be ACP traffic; the envelope
-also carries durable `Turn` footers). Two ways to
-read it:
-
-- **`WS /api/structured/:id`** — on connect, sends a `TranscriptSnapshot` and
-  a `ReducedState` covering the whole log as it stands, then streams
-  `ProjectionUpdate { transcript, state }` for everything that happens next.
-  There is no client-supplied resume cursor on this socket: every connection
-  gets the full snapshot, not a gap-filled continuation, so a client never
-  needs the replay endpoint just to obtain the current transcript. Use
-  replay instead for cursor-bounded pagination through the durable log —
-  history from before this connection, fetched a page at a time.
-- **`GET /api/sessions/:id/structured/replay`** — cursor-bounded pagination
-  over the durable log, returning one `StructuredReplayEvent` (`cursor`,
-  `transcript`, `state`) per matching line. `?since=<n>` returns the first
-  page after `n` (`since=0` selects from the beginning, i.e. the first
-  page); a client pages forward from there using the cursor of the last
-  event returned. `?before=<n>` returns the page immediately before `n`,
-  still in ascending order — passing both is a `400`. `?limit` defaults to
-  100 and is clamped to 500. Each call re-folds
-  the entire log from scratch to compute the state at every returned cursor,
-  so a page reflects exactly the *durable* state at its cursor, not an
-  approximation of it — at the cost of redoing the whole fold per request.
-  That durable state is not always identical to what a live client saw at
-  that moment, though: turn lifecycle transitions are broadcast live without
-  a durable event backing them (see [Prompt and cancel](#prompt-and-cancel-bounded-liveness)),
-  and a restored `Approval` row carries no pending nonce, because the nonce
-  never reached disk (see [Approvals](#approvals)) — replay is exact and
-  reconstructible, not a perfect record of everything the live view showed.
-  A session that is not a live structured session (terminal, or a dead
-  adapter) answers `409 not_structured` from either route rather than a
-  coherent-looking but stale reply.
-
-## Approvals
-
-An ACP `session/request_permission` callback becomes an `Approval` row plus a
-pending decision, entirely on the daemon side:
-
-- **Generation.** The daemon mints the nonce itself — a fresh
-  `Uuid::new_v4()` string per request — rather than using anything ACP's own
-  request carries. ACP permission callbacks have no request id of their own
-  that would double as one.
-- **Live-only placement.** The nonce lives in exactly one place: the
-  in-memory `pending_approvals` map keyed by nonce, and its mirror in
-  `ReducedState.pending_approval.nonce` on the live wire. It is never part of
-  the `Approval` row's `data` — the row is `RequestPermissionRequest`
-  serialized *without* the nonce.
-- **Secrecy from the agent and from durable history.** The adapter itself
-  never learns the nonce — it is a daemon-to-client secret, never sent back
-  over the ACP connection. It is likewise never written to the event log:
-  restoring an `Approval` row from disk (`Projection::restore_row`)
-  produces a historical row with no `pending_approval` in state, because the
-  nonce that would make it "pending" never made it to disk in the first
-  place. A restart therefore cannot resume a pending approval — see
-  [Persistence](#persistence-recovery-and-dead-sessions).
-- **One live approval at a time.** A new permission request mints its own
-  nonce, then cancels whatever was already pending (`cancel_pending_approvals`)
-  before installing itself as the new pending approval — ACP serializes
-  requests through one connection, so this only ever fires if an adapter
-  nonetheless overlaps two. Either way, the prior pending request is
-  cancelled/cleared before the new one is installed, so the newest request
-  wins.
-- **Single-use and duplicate resolution.**
-  `POST /api/sessions/:id/structured/approvals/:nonce` **always answers
-  `204`** for a known, live structured session — whether the nonce is the
-  one currently pending, one already consumed by an earlier answer, or one
-  that never existed. Only an unknown or non-structured *session* answers
-  otherwise (`404` / `409`). This is deliberate: two clients racing to answer the same
-  approval must not turn a harmless duplicate click into a client-visible
-  error. Whichever `POST` reaches the daemon first removes the nonce from
-  `pending_approvals` and is the one whose decision actually reaches the
-  adapter; every later `POST` for that nonce is a no-op `204`.
-- **Cancellation vs. denial.** A turn cancel or a session shutdown resolves
-  any pending approval with ACP's `Cancelled` outcome, not a `Deny` decision
-  — the adapter should read those as "the operation was withdrawn," not "the
-  operator refused it."
-- **Decision mapping.** `AllowOnce` and `AllowForSession` select the ACP
-  option of kind `AllowOnce` / `AllowAlways` from the request's own option
-  list. `Deny` prefers a one-shot refusal (`RejectOnce`) and falls back to a
-  permanent one (`RejectAlways`) only when that is the sole rejection option
-  offered; if neither is present, it answers `Cancelled`.
-
-## 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
-per-request id — the daemon's own notion of "the active turn" is the only
-thing a callback can be attributed to, so at most one turn may ever be
-in flight, and a cancelled turn must fully settle before the next prompt is
-allowed to claim the daemon's idea of "the active turn."
-
-- Prompts are accepted at any time: if the session is idle the daemon dispatches
-  immediately (`204`); if a turn is active the prompt is appended to a
-  server-side FIFO (`202 Accepted`, capped at 20 entries, `429` when full).
-  When the active turn completes, all queued prompts are concatenated with
-  `\n\n` and dispatched as the next turn. The queue is persisted in the session
-  sidecar and survives daemon restarts — clients never queue locally.
-  `ReducedState.queued_prompts` contains the current queue so every connected
-  client can render the pending messages.
-- A submitted prompt is appended as a durable `User` row before it claims the turn and
-  dispatches to ACP, so the transcript never depends on an adapter echoing the
-  operator's input. If that append fails, the prompt is not dispatched.
-- Cancel sends `session/cancel`, clears any pending approval as `Cancelled`,
-  and ends the turn's client-visible lifecycle immediately. The prompt queue
-  is preserved: after the cancelled turn settles, the queued prompts drain as
-  the next turn. If the session dies instead (settlement timeout), the queue
-  is cleared. If the cancelled turn was still *dispatched* to ACP (waiting on
-  its response), the daemon cannot simply forget it: ACP has not confirmed the
-  cancel yet, and a new prompt claiming "the active turn" while the old one is
-  still outstanding would make the next permission callback ambiguous between
-  the two.
-- So a cancelled-but-still-dispatched turn must **settle within
-  `CANCEL_GRACE` (500ms)** — either ACP acknowledges the prompt (however it
-  resolves) or that grace period runs out. If it settles in time, the next
-  prompt proceeds normally. If it does not, the daemon does not guess: it
-  marks the whole structured session dead (`fail_cancelled_acp_turn`) rather
-  than risk a callback resolving against the wrong turn. This is the bounded
-  half of "bounded liveness" — a structured session's prompt/cancel dance
-  either resolves promptly or the session is declared unusable, never left
-  in an indefinite ambiguous state.
-
-## Persistence, recovery, and dead sessions
-
-A structured session's durable state is three files in the sidecar
-directory: the sidecar itself (`<id>.json`), plus two next to it:
-
-- **`<id>.events.jsonl`** — the unified event log. Each line is either a raw
-  ACP `SessionNotification` (kept in its original JSON so old logs stay
-  readable) or a `{"maestroEvent": "user"|"approval", "row": …}` envelope
-  for a daemon-generated row. Both share the same 1-based line-position cursor. A
-  line a hard kill left half-written is terminated before the next append, so
-  it keeps its position and is skipped as malformed rather than corrupting
-  what follows. An append that fails *while the daemon is running* — a
-  `write_all` that errors after only a prefix reached disk, or a `flush` that
-  errors after a complete write — is rolled back to the exact byte length the
-  file was at before the call, so `last_seq` and the file's line count never
-  disagree and the same log handle can be appended to again immediately (#184).
-  If that rollback itself cannot restore the prior length, the append is
-  fatal: the log's consistency can no longer be promised, so the caller kills
-  the session instead of appending to it again.
-- **`<id>.recover`** — an empty marker file. Its only meaning is "the daemon
-  that wrote this shut down gracefully while this session was running, and
-  the next daemon may attempt to resume it." It is consumed (deleted) the
-  moment a recovery attempt reads it — one recovery attempt per graceful
-  shutdown, never a standing flag.
-
-Three ways a structured session ends up `Dead`, each with different
-persistence consequences:
-
-1. **The adapter exits, or a notification append to the event log fails,
-   while the daemon keeps running.** (An approval-row append failure is
-   narrower: as long as the log rolled back cleanly, it only cancels the
-   pending approval and rolls the unpersisted `Approval` row back out of the
-   live transcript, without marking the session dead — a snapshot taken after
-   the failure must never show a row durable replay could not reproduce
-   (#184). If the rollback itself did not restore the log's prior length,
-   this narrower path does not apply either: the session is marked dead the
-   same as any other append failure, since the log can no longer promise
-   `last_seq` matches its file.)
-   `mark_session_dead` applies the same natural-exit worktree rule
-   as a terminal session's own pane exiting (`docs/WORKTREES.md`): a pristine
-   worktree is removed, one holding unsaved work is left on disk. No recovery
-   marker is written. This death is permanent — a later daemon restart's
-   `recover()` finds the sidecar, sees no marker, and leaves the session
-   `Dead` without attempting to resume it.
-2. **A cancelled turn fails to settle within `CANCEL_GRACE`.** Same
-   consequence as (1): the session is marked dead through the same path, no
-   marker, no future resumption.
-3. **Graceful daemon shutdown**, while the session was still `Running`.
-   `mark_session_dead_after_shutdown` marks the session dead **without**
-   applying the worktree exit rule — the tree is kept exactly as it is,
-   pristine or not, because there is nothing "natural" about this exit — and
-   writes the `.recover` marker. The sidecar on disk therefore says `Dead`,
-   but is eligible for resumption.
-
-Recovery, on the next daemon's `recover()`: for every `Structured` sidecar
-not already adopted, the marker is consumed. When one was present and the
-sidecar carries a stored `acp_session_id`, the daemon spawns a fresh adapter
-with `SpawnConfig::load_session(acp_session_id)`, replays the
-entire durable event log into a new `Projection` (rebuilding the transcript
-and reduced state exactly as they were, with any restored `Approval` row
-landing as history — never as a re-armed pending approval, since its nonce
-never reached disk), and only then reopens the log for further appends. What
-the adapter streams back while its own `session/load` is in flight is
-discarded rather than appended, so the replayed history is not duplicated
-(see [The ACP handshake](#the-acp-handshake)). Success flips the session back
-to `Running`/`Idle`; failure (no stored `acp_session_id`, or the handshake
-itself failing) leaves it `Dead` with the failure reason as
-`activity_detail` — the same "tell the operator what to fix" pattern as a
-missing adapter binary.
-
-Pending approvals and their nonces never survive any of this. They live only
-in the in-memory `pending_approvals` map and the live `ReducedState`, both
-gone the instant the daemon that held them exits. Whatever ACP permission
-request was mid-flight when the old daemon died was already answered
-`Cancelled` on that daemon's own shutdown path, so a resumed session always
-starts with no pending approval.
-
-See `docs/RESTART.md` for what a *client* observes across a daemon restart,
-now that structured sessions exist alongside terminal ones.

docs/WORKTREES.md

@@ -35,18 +35,10 @@ The branch name is used verbatim as a relative path, so `feature/login` becomes
 back to a short hash of the branch.
 
 If that path exists, the daemon appends `-2`, then `-3`, and so on until it finds
-a free one.
-
-For a *new* branch (`create_branch: true`), the suffix goes on the branch name
-itself, and the directory follows since it is derived from the branch — a
-random handle can otherwise reuse the name of a branch some earlier, already
-removed worktree left behind, and `git worktree add -b` refuses outright even
-though the directory is free.
-
-For an *existing* branch (`create_branch: false`) the name must stay exact, so
-only the directory is suffixed — a second worktree of the same branch is not
-what happens here, because git refuses to check the same branch out twice and
-the branch picker already marks branches that are checked out elsewhere.
+a free one. The suffix names the **directory only**. The branch is whatever was
+requested; a second worktree of the same branch is not what happens here, because
+git refuses to check the same branch out twice and the branch picker already
+marks branches that are checked out elsewhere.
 
 ### The `worktree_root` override
 
@@ -75,17 +67,27 @@ The point of refusing rather than cleaning up is that the session stays as the
 operator's handle on their own unfinished work. A session that is killed while
 its worktree still matters leaves a directory nobody is looking at.
 
+A consequence, accepted deliberately: a feature branch almost always has unpushed
+commits, so `--force` is the ordinary way to end a session, not an exception.
+That is only safe because force never removes what blocked.
+
 ### `--force`
 
-`--force` overrides the refusal and **removes the worktree**, even when it holds
-unsaved work. The operator sees the breakdown in the confirmation prompt and
-decides; once confirmed, the tree is gone.
+`--force` overrides the refusal and nothing else. It ends the session and
+**leaves the worktree on disk**, untouched. Force never removes a tree that
+would have blocked. A tree whose guard is clear never needed the override, so a
+forced kill removes it as usual — force changes what happens to blocked work,
+not ordinary cleanup.
 
 In the web client the kill button sends the unforced `DELETE` straight away —
 there is no pre-confirmation, because the daemon is the one that decides. Only
 the refusal raises a prompt, and that prompt names what is in the way and offers
 "Force kill", which repeats the request with `force=true`.
 
+Ending a session and destroying its work are two separate acts. Maestro only
+performs the first one. Removing a tree it left behind is the operator's own
+`git worktree remove`, chosen while looking at exactly what would be lost.
+
 ### Exiting on its own
 
 A session that ends by itself — the command finished, the operator typed `exit` —
@@ -103,12 +105,17 @@ once. A removed tree drops off the record, so dismissing the session afterwards
 does not refuse: there is no guard left to trip.
 
 A tree that was left alone stays attached to the dead record, where dismissing it
-later goes through `--force`, which removes it. The same holds when the probe
-itself fails: nothing is destroyed.
+later goes through `--force`, which leaves it on disk too. The same holds when
+the probe itself fails: nothing is destroyed.
 
-## Trees left behind by natural exit
+## Nothing is removed on the operator's behalf
 
-A forced kill always removes the worktree. A natural exit with unsaved work
-leaves the tree on disk — there is no operator confirmation in that path. Those
-trees are ordinary git worktrees; `git worktree list` finds them and
-`git worktree remove` removes them.
+There is no store of worktrees the daemon is holding, no list endpoint, and no
+reclaim command. A tree left behind by a forced kill or a dirty exit is an
+ordinary git worktree on disk; `git worktree list` finds it and
+`git worktree remove` removes it.
+
+That is deliberate. A tracked list of trees pending deletion is a second place
+the truth can live, and it goes stale the moment somebody removes a directory by
+hand. Git already knows which worktrees exist, and removing one is not a
+decision Maestro is better placed to make.

fixtures/command-resolution.json

@@ -1,120 +0,0 @@
-{
-  "_description": "the parity fixture for #199's command resolver — every case here is asserted identically by crates/maestro-protocol/src/display.rs (command_program/command_tool) and web/src/toolIcon.ts (splitCommand). `program` is the resolved, basenamed program; `tool` is the icon id it maps to, or null when unrecognised/ambiguous.",
-  "cases": [
-    { "command": "claude", "program": "claude", "tool": "claude" },
-    { "command": "claude --resume", "program": "claude", "tool": "claude" },
-    { "command": "CLAUDE", "program": "CLAUDE", "tool": "claude" },
-    { "command": "/usr/local/bin/claude -p hi", "program": "claude", "tool": "claude" },
-    { "command": "./bin/claude", "program": "claude", "tool": "claude" },
-    { "command": "FOO=1 BAR=2 claude", "program": "claude", "tool": "claude" },
-    { "command": "FOO=\"bar baz\" claude", "program": "claude", "tool": "claude" },
-    { "command": "FOO='bar baz' claude", "program": "claude", "tool": "claude" },
-    { "command": "FOO=bar\\ baz claude", "program": "claude", "tool": "claude" },
-    { "command": "'/usr/local/bin/claude'", "program": "claude", "tool": "claude" },
-    { "command": "\"/opt/my agent/claude\" --resume", "program": "claude", "tool": "claude" },
-    { "command": "env -i claude", "program": "claude", "tool": "claude" },
-    { "command": "env --ignore-environment claude", "program": "claude", "tool": "claude" },
-    { "command": "sudo -u root claude", "program": "claude", "tool": "claude" },
-    { "command": "sudo --user=root claude", "program": "claude", "tool": "claude" },
-    { "command": "sudo -- claude --resume", "program": "claude", "tool": "claude" },
-    { "command": "nohup claude", "program": "claude", "tool": "claude" },
-    { "command": "time claude", "program": "claude", "tool": "claude" },
-    { "command": "time -p claude", "program": "claude", "tool": "claude" },
-    { "command": "time -- claude", "program": "claude", "tool": "claude" },
-    { "command": "time -p -- claude", "program": "claude", "tool": "claude" },
-    { "command": "time -pp claude", "program": "time", "tool": null },
-    { "command": "time -p -p claude", "program": "time", "tool": null },
-    { "command": "time -o /tmp/t.log claude", "program": "time", "tool": null },
-    { "command": "command claude", "program": "claude", "tool": "claude" },
-    { "command": "command -v claude", "program": "command", "tool": null },
-    { "command": "command -V claude", "program": "command", "tool": null },
-    { "command": "npx --yes claude-code", "program": "claude-code", "tool": "claude" },
-    { "command": "npx claude-code", "program": "claude-code", "tool": "claude" },
-    { "command": "pnpm --silent dlx claude-code", "program": "claude-code", "tool": "claude" },
-    { "command": "pnpm -C ./pkg dlx claude-code", "program": "claude-code", "tool": "claude" },
-    { "command": "pnpm dlx claude-code", "program": "claude-code", "tool": "claude" },
-    { "command": "pnpm dlx -s claude-code", "program": "claude-code", "tool": "claude" },
-    { "command": "pnpm dlx --silent claude-code", "program": "claude-code", "tool": "claude" },
-    { "command": "yarn --silent dlx claude-code", "program": "claude-code", "tool": "claude" },
-    { "command": "yarn dlx -q claude-code", "program": "claude-code", "tool": "claude" },
-    { "command": "yarn dlx --quiet claude-code", "program": "claude-code", "tool": "claude" },
-    { "command": "bun x claude-code", "program": "claude-code", "tool": "claude" },
-    { "command": "bunx claude-code", "program": "claude-code", "tool": "claude" },
-    { "command": "uvx claude-code", "program": "claude-code", "tool": "claude" },
-    { "command": "bun x --bun claude-code", "program": "claude-code", "tool": "claude" },
-    { "command": "bunx --bun claude-code", "program": "claude-code", "tool": "claude" },
-    { "command": "bun x -p @anthropic-ai/claude-code claude-code", "program": "claude-code", "tool": "claude" },
-    { "command": "bunx --package @anthropic-ai/claude-code claude-code", "program": "claude-code", "tool": "claude" },
-    { "command": "bun x --package=@anthropic-ai/claude-code claude-code", "program": "claude-code", "tool": "claude" },
-    { "command": "bunx --no-install claude-code", "program": "claude-code", "tool": "claude" },
-    { "command": "bun x --verbose claude-code", "program": "claude-code", "tool": "claude" },
-    { "command": "bunx --silent claude-code", "program": "claude-code", "tool": "claude" },
-    { "command": "bun --bun x claude-code", "program": "bun", "tool": null },
-    { "command": "pnpm dlx --package foo claude-code", "program": "claude-code", "tool": "claude" },
-    { "command": "pnpm dlx --package=foo claude-code", "program": "claude-code", "tool": "claude" },
-    { "command": "pnpm dlx --package= claude-code", "program": "pnpm", "tool": null },
-    { "command": "pnpm dlx --package", "program": "pnpm", "tool": null },
-    { "command": "pnpm dlx -c \"claude-code\"", "program": "pnpm", "tool": null },
-    { "command": "pnpm --package=typescript dlx tsc", "program": "tsc", "tool": null },
-    { "command": "pnpm dlx --unknown-flag claude-code", "program": "pnpm", "tool": null },
-    { "command": "yarn dlx --package foo claude-code", "program": "claude-code", "tool": "claude" },
-    { "command": "yarn dlx --package=foo claude-code", "program": "claude-code", "tool": "claude" },
-    { "command": "yarn dlx -p foo claude-code", "program": "claude-code", "tool": "claude" },
-    { "command": "yarn dlx --package= claude-code", "program": "yarn", "tool": null },
-    { "command": "yarn dlx -p", "program": "yarn", "tool": null },
-    { "command": "yarn dlx -p --quiet claude-code", "program": "yarn", "tool": null },
-    { "command": "bunx --package= claude-code", "program": "bunx", "tool": null },
-    { "command": "bunx --package", "program": "bunx", "tool": null },
-    { "command": "bun x -p --silent claude-code", "program": "bun", "tool": null },
-    { "command": "sudo env -i claude", "program": "claude", "tool": "claude" },
-    { "command": "FOO=1 sudo BAR=2 claude", "program": "claude", "tool": "claude" },
-    { "command": "env -iv claude", "program": "claude", "tool": "claude" },
-    { "command": "sudo -nE claude", "program": "claude", "tool": "claude" },
-    { "command": "sudo -uroot claude", "program": "claude", "tool": "claude" },
-    { "command": "sudo -u", "program": "sudo", "tool": null },
-    { "command": "env --unset= claude", "program": "env", "tool": null },
-    { "command": "sudo --user= claude", "program": "sudo", "tool": null },
-    { "command": "sudo --user \"\" claude", "program": "sudo", "tool": null },
-    { "command": "sudo -nu claude", "program": "sudo", "tool": null },
-    { "command": "env -S 'python3 -u' script.py", "program": "env", "tool": null },
-    { "command": "npx -c \"claude --version\"", "program": "npx", "tool": null },
-    { "command": "npx --call \"claude --version\"", "program": "npx", "tool": null },
-    { "command": "command FOO=1 claude", "program": "FOO=1", "tool": null },
-    { "command": "nohup FOO=1 claude", "program": "FOO=1", "tool": null },
-    { "command": "npx FOO=1 claude-code", "program": "FOO=1", "tool": null },
-    { "command": "pnpm dlx FOO=1 claude-code", "program": "FOO=1", "tool": null },
-    { "command": "yarn dlx FOO=1 claude-code", "program": "FOO=1", "tool": null },
-    { "command": "bun x FOO=1 claude-code", "program": "FOO=1", "tool": null },
-    { "command": "bunx FOO=1 claude-code", "program": "FOO=1", "tool": null },
-    { "command": "uvx FOO=1 claude-code", "program": "FOO=1", "tool": null },
-    { "command": "sudo time FOO=1 claude", "program": "claude", "tool": "claude" },
-    { "command": "nohup env FOO=1 claude", "program": "claude", "tool": "claude" },
-    { "command": "sudo command FOO=1 claude", "program": "FOO=1", "tool": null },
-    { "command": "command nohup FOO=1 claude", "program": "FOO=1", "tool": null },
-    { "command": "time command FOO=1 claude", "program": "FOO=1", "tool": null },
-    { "command": "\"FOO=1\" claude", "program": "FOO=1", "tool": null },
-    { "command": "FOO\\=1 claude", "program": "FOO=1", "tool": null },
-    { "command": "F\"O\"O=1 claude", "program": "FOO=1", "tool": null },
-    { "command": "F\\OO=1 claude", "program": "FOO=1", "tool": null },
-    { "command": "\"FOO\"=1 claude", "program": "FOO=1", "tool": null },
-    { "command": "F\"\"OO=1 claude", "program": "FOO=1", "tool": null },
-    { "command": "claude\nclaude-code", "program": "claude", "tool": null },
-    { "command": "clau\\\nde --resume", "program": "claude", "tool": "claude" },
-    { "command": "npx opencode", "program": "opencode", "tool": "opencode" },
-    { "command": "pnpm dlx opencode run", "program": "opencode", "tool": "opencode" },
-    { "command": "pnpm claude", "program": "pnpm", "tool": null },
-    { "command": "yarn claude", "program": "yarn", "tool": null },
-    { "command": "claude-code-acp", "program": "claude-code-acp", "tool": null },
-    { "command": "hx src/main.rs", "program": "hx", "tool": null },
-    { "command": "bash", "program": "bash", "tool": "shell" },
-    { "command": "opencode", "program": "opencode", "tool": "opencode" },
-    { "command": "sudo", "program": "sudo", "tool": null },
-    { "command": "", "program": "", "tool": null },
-    { "command": "npx --unknown-flag claude-code", "program": "npx", "tool": null },
-    { "command": "claude | tee log.txt", "program": "claude", "tool": null },
-    { "command": "claude; echo done", "program": "claude;", "tool": null },
-    { "command": "claude && echo done", "program": "claude", "tool": null },
-    { "command": "echo hi $(claude)", "program": "echo", "tool": null },
-    { "command": "claude \"unterminated", "program": "claude", "tool": null }
-  ]
-}

flake.nix

@@ -148,7 +148,7 @@
             pnpmDeps = (pkgs.fetchPnpmDeps.override { pnpm = pkgs.pnpm_10; }) {
               inherit (finalAttrs) pname version src;
               fetcherVersion = 3;
-              hash = "sha256-FEWOAtSFvOWHeCNR0RK8JQ/ssW31qmShu1YD2GuqioQ=";
+              hash = "sha256-hOqiAbnjKsoQnV8lgto5HspDsLIb+48sNLkShIjCZPQ=";
             };
 
             buildPhase = ''

web/index.html

@@ -23,7 +23,7 @@
     <meta name="apple-mobile-web-app-title" content="maestro" />
   </head>
   <body>
-    <div id="root"></div>
-    <script type="module" src="/src/index.tsx"></script>
+    <div id="app"></div>
+    <script type="module" src="/src/main.ts"></script>
   </body>
 </html>

web/package-lock.json

@@ -11,8 +11,7 @@
         "@fontsource/jetbrains-mono": "^5.3.0",
         "@xterm/addon-fit": "^0.10.0",
         "@xterm/addon-webgl": "^0.19.0",
-        "@xterm/xterm": "^5.5.0",
-        "marked": "^18.0.11"
+        "@xterm/xterm": "^5.5.0"
       },
       "devDependencies": {
         "happy-dom": "^20.11.6",
@@ -1223,18 +1222,6 @@
         "@jridgewell/sourcemap-codec": "^1.5.5"
       }
     },
-    "node_modules/marked": {
-      "version": "18.0.11",
-      "resolved": "https://registry.npmjs.org/marked/-/marked-18.0.11.tgz",
-      "integrity": "sha512-HnslJfsZkRPBDJRHvVtAaWlZHEpSu7u8LgQuJCELjRKuWR+hpq4A7sLq3p8HaI9ypVoXDXxV34CsQJEe1+J5Aw==",
-      "license": "MIT",
-      "bin": {
-        "marked": "bin/marked.js"
-      },
-      "engines": {
-        "node": ">= 20"
-      }
-    },
     "node_modules/ms": {
       "version": "2.1.3",
       "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",

web/package.json

@@ -6,7 +6,7 @@
   "packageManager": "pnpm@9.15.4",
   "scripts": {
     "dev": "vite",
-    "build": "tsc -b tsconfig.build.json && vite build",
+    "build": "tsc -b && vite build",
     "preview": "vite preview",
     "typecheck": "tsc -b --noEmit",
     "test": "vitest run",
@@ -16,23 +16,12 @@
     "@fontsource/jetbrains-mono": "^5.3.0",
     "@xterm/addon-fit": "^0.10.0",
     "@xterm/addon-webgl": "^0.19.0",
-    "@xterm/xterm": "^5.5.0",
-    "marked": "^18.0.11",
-    "react": "^19.2.8",
-    "react-dom": "^19.2.8"
+    "@xterm/xterm": "^5.5.0"
   },
   "devDependencies": {
-    "@tailwindcss/vite": "^4.3.3",
-    "@testing-library/jest-dom": "^7.0.1",
-    "@testing-library/react": "^16.3.3",
-    "@types/react": "^19.2.18",
-    "@types/react-dom": "^19.2.7",
-    "@vitejs/plugin-react": "^4.7.0",
     "happy-dom": "^20.11.6",
-    "tailwindcss": "^4.3.3",
     "typescript": "^5.6.3",
     "vite": "^5.4.10",
-    "vitest": "^2.1.9",
-    "zustand": "^5.0.15"
+    "vitest": "^2.1.9"
   }
 }

web/src/App.tsx

@@ -1,449 +0,0 @@
-// The app shell (#253): everything main.ts used to wire by hand, as one React
-// tree. The stores are the state — a catalog store fed by the events socket, a
-// layout store holding the tab/split tree — and the hash route is a deep link
-// into the latter.
-
-import { useCallback, useEffect, useMemo, useRef, useState } from "react";
-import { useStore } from "zustand";
-
-import "@fontsource/jetbrains-mono/400.css";
-import "@fontsource/jetbrains-mono/500.css";
-import "@fontsource/jetbrains-mono/600.css";
-import "@fontsource/jetbrains-mono/700.css";
-
-import { createSession, fetchNames, getDaemonInfo, gitRoot, projects as fetchProjects } from "./api.js";
-import {
-  CommandSet,
-  DEFAULT_LEADER,
-  controlByte,
-  defineCommands,
-  isBarTypingTarget,
-} from "./commands.js";
-import { ThemeProvider } from "./contexts/ThemeContext.js";
-import { CommandBar, SPAWN_DIRECTORY_EVENT, useCommandBar } from "./components/commandBar/index.js";
-import { DaemonLink, createDaemonLinkStore } from "./components/daemon/DaemonLink.js";
-import { RestartOverlay } from "./components/daemon/RestartOverlay.js";
-import { HelpOverlay } from "./components/dialogs/index.js";
-import { useViewport } from "./components/hooks/useViewport.js";
-import { Drawer } from "./components/layout/Drawer.js";
-import { MultiView, type MultiViewHandle } from "./components/layout/MultiView.js";
-import { Sidebar } from "./components/sidebar/index.js";
-import {
-  SpawnModal,
-  spawnSimilarProjectSeed,
-  spawnSimilarSeed,
-  useFastForward,
-  type SpawnFormProps,
-} from "./components/spawn/index.js";
-import { buildFastForwardRequest, fastForwardSeed, resolveFastForward } from "./fastForward.js";
-import { useHashRouter } from "./hooks/useHashRouter.js";
-import { usePreview } from "./hooks/usePreview.js";
-import { activeTab, findLeaf, openSessions } from "./layout.js";
-import { createCatalogStore, type CatalogStore } from "./stores/catalogStore.js";
-import { createLayoutStore, type LayoutStore } from "./stores/layoutStore.js";
-import type { Project, Session, SpawnPreset, Uuid } from "./types.js";
-import {
-  FOCUS_PANE_EVENT,
-  OPEN_SPAWN_EVENT,
-  SESSION_SELECT_EVENT,
-  SPAWN_SIMILAR_EVENT,
-  requestOpenSpawn,
-  requestToggleDrawer,
-} from "./uiEvents.js";
-
-type SpawnSeed = SpawnFormProps["seed"];
-
-/** Open modal state: `seed` is what the form starts from (undefined for a
- *  plain spawn), `newTab` where the created session lands. */
-interface SpawnState {
-  seed: SpawnSeed;
-  newTab: boolean;
-}
-
-export function App() {
-  return (
-    <ThemeProvider>
-      <Shell />
-    </ThemeProvider>
-  );
-}
-
-function Shell() {
-  useViewport();
-
-  // One instance each, for the life of the page.
-  const catalogStore = useMemo(() => createCatalogStore(), []);
-  const layoutStore = useMemo(() => createLayoutStore(), []);
-  const linkStore = useMemo(() => createDaemonLinkStore(), []);
-
-  const sessions = useStore(catalogStore, (s: CatalogStore) => s.sessions);
-  const connected = useStore(catalogStore, (s: CatalogStore) => s.connected);
-  const loaded = useStore(catalogStore, (s: CatalogStore) => s.loaded);
-  const layout = useStore(layoutStore, (s: LayoutStore) => s.layout);
-
-  const [homeDir, setHomeDir] = useState<string | undefined>(undefined);
-  const [leader, setLeader] = useState(DEFAULT_LEADER);
-  const [spawn, setSpawn] = useState<SpawnState | null>(null);
-
-  const { route, navigate } = useHashRouter();
-  const { preview, previewedSessionId, commit: commitPreview, end: endPreview } = usePreview({
-    store: layoutStore,
-  });
-
-  useEffect(() => {
-    catalogStore.getState().start();
-    return () => catalogStore.getState().stop();
-  }, [catalogStore]);
-
-  // The daemon's home dir abbreviates cwds to `~/…`; its leader rebinds the
-  // chords hanging off it (#159), so the `?` overlay and the command bar show
-  // the configured chord rather than the default. Absolute paths and the
-  // default leader are fine fallbacks.
-  useEffect(() => {
-    void getDaemonInfo()
-      .then((info) => {
-        setHomeDir(info.home_dir);
-        if (info.leader) setLeader(info.leader);
-      })
-      .catch(() => {});
-  }, []);
-
-  // Installed mobile browsers suspend timers and WebSockets in the background.
-  // Replacing the socket on return avoids leaving the restart overlay up after
-  // a transient lost connection has already recovered.
-  useEffect(() => {
-    const recover = () => {
-      if (document.visibilityState !== "visible") return;
-      void linkStore.getState().probe();
-      catalogStore.getState().reconnect();
-    };
-    document.addEventListener("visibilitychange", recover);
-    window.addEventListener("pageshow", recover);
-    window.addEventListener("online", recover);
-    return () => {
-      document.removeEventListener("visibilitychange", recover);
-      window.removeEventListener("pageshow", recover);
-      window.removeEventListener("online", recover);
-    };
-  }, [catalogStore, linkStore]);
-
-  // The catalog is the authority on which sessions exist: a pane for a session
-  // that is no longer listed gets closed here, rather than waiting on its own
-  // socket to notice. Only once a list has actually landed — before that,
-  // "not listed" means "not known yet" and would close every restored pane.
-  useEffect(() => {
-    if (!loaded) return;
-    for (const id of openSessions(layout)) {
-      if (!sessions.has(id)) layoutStore.getState().closeSession(id);
-    }
-  }, [loaded, sessions, layout, layoutStore]);
-
-  const tab = activeTab(layout);
-  const focusedSessionId =
-    (tab.focusedLeafId && findLeaf(tab.root, tab.focusedLeafId)?.sessionId) || null;
-  const focusedSession = focusedSessionId ? sessions.get(focusedSessionId) : undefined;
-
-  /** Open/focus a session, settling any preview of it in place. Shared by the
-   *  hash router and the sidebar's click-driven path (#133), which can't rely
-   *  on `hashchange` alone — a split or drag can move focus without the hash
-   *  changing, leaving a click back onto that row silently ignored. */
-  const focusSession = useCallback(
-    (sessionId: Uuid) => {
-      // `commit` cancels a pending preview and opens the session; the layout
-      // store settles a matching preview in place rather than moving it twice.
-      commitPreview(sessionId);
-      navigate({ kind: "attach", sessionId });
-    },
-    [commitPreview, navigate],
-  );
-
-  // A deep link (`#/attach/:id`) opens the session it names. Only the route
-  // *changing* does this: focusing a pane rewrites the hash, and re-opening
-  // from that would fight the layout the operator just arranged.
-  const lastRouteRef = useRef<string | null>(null);
-  useEffect(() => {
-    const key = route.kind === "attach" ? route.sessionId : "catalog";
-    if (lastRouteRef.current === key) return;
-    lastRouteRef.current = key;
-    if (route.kind === "attach") layoutStore.getState().openSession(route.sessionId);
-  }, [route, layoutStore]);
-
-  /** Show a freshly spawned session: it gets its own pane rather than evicting
-   *  whatever the operator was reading. */
-  const mountSpawned = useCallback(
-    (session: Session, opts?: { newTab?: boolean }) => {
-      layoutStore.getState().openSessionBeside(session.id, opts);
-      navigate({ kind: "attach", sessionId: session.id });
-    },
-    [layoutStore, navigate],
-  );
-
-  const openSpawn = useCallback(
-    (seed: SpawnSeed, newTab: boolean) => {
-      endPreview();
-      setSpawn({ seed, newTab });
-    },
-    [endPreview],
-  );
-
-  /** The plain spawn: the session you were last on preselects its project, so
-   *  `n` then Enter spawns another session there without touching the picker.
-   *  It lands in a new tab, not a split of the pane you were reading (#100). */
-  const openPlainSpawn = useCallback(() => {
-    openSpawn(focusedSession ? spawnSimilarProjectSeed(focusedSession) : undefined, true);
-  }, [focusedSession, openSpawn]);
-
-  /** The focused session's project — its base repo for a worktree session, its
-   *  cwd otherwise (the rule spawnSimilarProjectSeed uses). */
-  const focusedProjectCwd = focusedSession
-    ? (focusedSession.worktree?.base_repo ?? focusedSession.cwd)
-    : undefined;
-
-  const fastForward = useFastForward({
-    focusedCwd: focusedProjectCwd,
-    onSpawned: (session) => mountSpawned(session),
-    onFallback: (seed) => openSpawn(seed, false),
-  });
-
-  const bar = useCommandBar({ onOpen: endPreview });
-
-  useEffect(() => {
-    const onOpenSpawnEvent = () => openPlainSpawn();
-    const onSpawnSimilar = (e: Event) => {
-      const s = (e as CustomEvent<Session>).detail;
-      if (s) openSpawn(spawnSimilarSeed(s), false);
-    };
-    const onSessionSelect = (e: Event) => focusSession((e as CustomEvent<Uuid>).detail);
-    document.addEventListener(OPEN_SPAWN_EVENT, onOpenSpawnEvent);
-    document.addEventListener(SPAWN_SIMILAR_EVENT, onSpawnSimilar);
-    document.addEventListener(SESSION_SELECT_EVENT, onSessionSelect);
-    return () => {
-      document.removeEventListener(OPEN_SPAWN_EVENT, onOpenSpawnEvent);
-      document.removeEventListener(SPAWN_SIMILAR_EVENT, onSpawnSimilar);
-      document.removeEventListener(SESSION_SELECT_EVENT, onSessionSelect);
-    };
-  }, [openPlainSpawn, openSpawn, focusSession]);
-
-  // Enter on a `~` row in the command bar (docs/COMMAND-BAR.md): the same
-  // fast-forward spawn, aimed at the chosen directory instead of the most
-  // recent project.
-  useEffect(() => {
-    const onSpawnDirectory = (e: Event) => {
-      void spawnInDirectory((e as CustomEvent<string>).detail, mountSpawned, (seed) =>
-        openSpawn(seed, false),
-      );
-    };
-    document.addEventListener(SPAWN_DIRECTORY_EVENT, onSpawnDirectory);
-    return () => document.removeEventListener(SPAWN_DIRECTORY_EVENT, onSpawnDirectory);
-  }, [mountSpawned, openSpawn]);
-
-  // Tab in the session list hands the keyboard to the pane; leader-h hands it
-  // back the other way. Handing it to a previewed pane is choosing it: the
-  // preview settles rather than snapping back when the list blurs.
-  const sidebarRef = useRef<HTMLDivElement>(null);
-  const viewRef = useRef<MultiViewHandle>(null);
-  const focusPane = useCallback(() => {
-    if (previewedSessionId) commitPreview(previewedSessionId);
-    viewRef.current?.focusPane();
-  }, [previewedSessionId, commitPreview]);
-
-  useEffect(() => {
-    document.addEventListener(FOCUS_PANE_EVENT, focusPane);
-    return () => document.removeEventListener(FOCUS_PANE_EVENT, focusPane);
-  }, [focusPane]);
-
-  // The global half of the command registry (#148). `n` opens the spawn modal
-  // and `N` fast-forwards a spawn (#67); both are plain keys, so the set's own
-  // `isTypingTarget` keeps them out of form fields and the terminal's hidden
-  // textarea. Leader-h moves the keyboard between the list and the pane — a
-  // chord, because an attached terminal owns every plain keystroke
-  // (docs/COMMAND-BAR.md).
-  useEffect(() => {
-    if (bar.open || spawn) return;
-    const spawnKeys = new CommandSet(
-      defineCommands({
-        "spawn.open": openPlainSpawn,
-        "spawn.fastForward": () => void fastForward(),
-      }),
-    );
-    const focusKeys = new CommandSet(
-      defineCommands(
-        {
-          "focus.toggle": () => {
-            if (sidebarRef.current?.contains(document.activeElement)) {
-              focusPane();
-            } else {
-              // No-op on desktop; on mobile the list is off-canvas until the
-              // drawer opens, so the focus has somewhere to land.
-              requestToggleDrawer();
-              sidebarRef.current?.querySelector<HTMLElement>("[tabindex]")?.focus();
-            }
-          },
-          // The escape hatch: binding ctrl-k takes readline's
-          // kill-to-end-of-line away from every pane, and leader ctrl-k gives
-          // it back as the literal 0x0B byte (docs/COMMAND-BAR.md).
-          "pane.literalCtrlK": () => viewRef.current?.sendInput("\x0b"),
-          // The leader pressed twice, tmux-style: one literal leader byte,
-          // built from the leader itself so a rebound one sends its own (#158).
-          "pane.literalLeader": () => viewRef.current?.sendInput(controlByte(leader)),
-        },
-        leader,
-      ),
-      { leader },
-    );
-    const onKeydown = (e: KeyboardEvent) => {
-      if (focusKeys.handle(e)) return;
-      if (isBarTypingTarget(e.target)) return;
-      spawnKeys.handle(e);
-    };
-    window.addEventListener("keydown", onKeydown, true);
-    return () => window.removeEventListener("keydown", onKeydown, true);
-  }, [bar.open, spawn, openPlainSpawn, fastForward, focusPane, leader]);
-
-  const openIds = useMemo(() => openSessions(layout), [layout]);
-  const barSessions = useMemo(() => [...sessions.values()], [sessions]);
-
-  return (
-    <>
-      <Drawer
-        sidebar={
-          <div ref={sidebarRef} className="contents">
-          <Sidebar
-            store={catalogStore}
-            homeDir={homeDir}
-            activeId={focusedSessionId}
-            openIds={openIds}
-            previewId={previewedSessionId}
-            linkStore={linkStore}
-            onSelect={(id) => focusSession(id)}
-            onPreview={preview}
-            onSpawn={openPlainSpawn}
-            onSpawnDefaults={() => void fastForward()}
-            onSpawnSimilar={(s) => openSpawn(spawnSimilarSeed(s), false)}
-            onFocusPane={focusPane}
-          />
-          </div>
-        }
-      >
-        <MultiView
-          ref={viewRef}
-          store={layoutStore}
-          // Undefined until the first list lands: MultiView's boot
-          // reconciliation prunes against it, and an empty map would take
-          // every restored pane with it.
-          sessions={loaded ? sessions : undefined}
-          onDisconnect={(id) => layoutStore.getState().closeSession(id)}
-          emptyState={<Welcome onSpawn={requestOpenSpawn} />}
-        />
-      </Drawer>
-
-      <DaemonLink store={linkStore} connected={connected} />
-      <RestartOverlay store={linkStore} />
-      <HelpOverlay />
-
-      {bar.open && (
-        <CommandBar
-          sessions={barSessions}
-          homeDir={homeDir}
-          onOpenSession={(id) => {
-            bar.closeBar();
-            focusSession(id);
-          }}
-          onClose={bar.closeBar}
-        />
-      )}
-
-      {spawn && (
-        <SpawnModal
-          seed={spawn.seed}
-          onSuccess={(session) => mountSpawned(session, { newTab: spawn.newTab })}
-          onClose={() => setSpawn(null)}
-        />
-      )}
-    </>
-  );
-}
-
-async function spawnPresets(): Promise<SpawnPreset[]> {
-  try {
-    const info = await getDaemonInfo();
-    if (info.presets?.length) return info.presets;
-  } catch {
-    // keep fallbacks
-  }
-  const { FALLBACK_PRESETS } = await import("./components/spawn/model.js");
-  return FALLBACK_PRESETS;
-}
-
-/** A directory the project scan never saw stands in as its own project; one
- *  outside any repo spawns without a worktree, since there is no repo to cut a
- *  branch from. Anything still unresolved opens the pre-filled form. */
-async function spawnInDirectory(
-  path: string,
-  onSpawned: (session: Session) => void,
-  onFallback: (seed: SpawnSeed) => void,
-): Promise<void> {
-  const [discovered, handle] = await Promise.all([
-    fetchProjects().catch(() => [] as Project[]),
-    fetchNames(1)
-      .then((batch) => batch.names[0])
-      .catch(() => undefined),
-  ]);
-  const presets = await spawnPresets();
-  const known = discovered.find((p) => p.path === path);
-  const project: Project = known ?? { path, name: path.split("/").filter(Boolean).pop() ?? path };
-  const resolved = resolveFastForward([project], presets, handle, path);
-  const req = buildFastForwardRequest(resolved);
-  if (req) {
-    const inRepo =
-      known !== undefined ||
-      (await gitRoot(path)
-        .then((r) => !!r.root)
-        .catch(() => false));
-    if (!inRepo) delete req.worktree;
-    try {
-      onSpawned(await createSession(req));
-      return;
-    } catch {
-      // A failed POST degrades to the pre-filled form, never a dead row.
-    }
-  }
-  onFallback(fastForwardSeed(resolved));
-}
-
-/** The content pane with nothing open. The ☰ is mobile-only: with no pane
- *  there is no pane header to carry it, so the drawer would be swipe-only. */
-function Welcome({ onSpawn }: { onSpawn(): void }) {
-  return (
-    <div className="empty content-welcome">
-      <div className="empty-glyph" aria-hidden="true">
-        ⌘
-      </div>
-      <div className="empty-title">No session open</div>
-      <p className="empty-hint">
-        Pick a session from the list, or start a new one. Open sessions keep streaming in the
-        background — switching back is instant.
-      </p>
-      <p className="empty-hint">
-        Press <kbd>?</kbd> for keyboard shortcuts.
-      </p>
-      <div className="empty-actions">
-        <button
-          type="button"
-          className="btn btn-ghost welcome-sessions"
-          onClick={() => requestToggleDrawer()}
-        >
-          ☰ Sessions
-        </button>
-        <button
-          type="button"
-          className="btn btn-primary"
-          title="Draft pane: n — fast-forward spawn: N"
-          onClick={onSpawn}
-        >
-          + Spawn session
-        </button>
-      </div>
-    </div>
-  );
-}

web/src/api.ts

@@ -11,9 +11,6 @@ import type {
   Projects,
   RecentDirs,
   Session,
-  StructuredApprovalDecision,
-  StructuredConfigRequest,
-  StructuredPromptRequest,
   Uuid,
 } from "./types.js";
 
@@ -94,17 +91,14 @@ export async function killSession(id: Uuid, force = false): Promise<void> {
   );
 }
 
-/** Change one option advertised by a live ACP session. */
-export async function setStructuredConfig(
-  id: Uuid,
-  req: StructuredConfigRequest,
-): Promise<void> {
-  await jsonOrError(
-    await fetch(routes.structuredConfig(id), {
+/** Respawn a dormant session under its own uuid and sidecar (#166/#168).
+ * Refused with `409` (`already_running` / `cwd_missing`) when there is
+ * nothing a respawn could fix. */
+export async function resumeSession(id: Uuid): Promise<Session> {
+  return jsonOrError(
+    await fetch(routes.sessionResume(id), {
       method: "POST",
       credentials: "same-origin",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify(req),
     }),
   );
 }
@@ -170,53 +164,4 @@ export async function fetchBranches(path: string): Promise<Branches> {
   return jsonOrError(await fetch(url, { credentials: "same-origin" }));
 }
 
-/** Send a prompt to a structured session's ACP turn (#138). `409
- * turn_in_flight` when one is already active — the caller reflects that from
- * `ReducedState.turn` instead of racing this call. */
-export async function sendStructuredPrompt(id: Uuid, prompt: string): Promise<void> {
-  await jsonOrError(
-    await fetch(routes.structuredPrompt(id), {
-      method: "POST",
-      credentials: "same-origin",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify({ prompt } satisfies StructuredPromptRequest),
-    }),
-  );
-}
-
-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(
-    await fetch(routes.structuredCancel(id), { method: "POST", credentials: "same-origin" }),
-  );
-}
-
-/** Answer a pending ACP permission request (#139). Always resolves once the
- * session itself is a live structured session — a nonce that is unknown or
- * already consumed still answers `204` (docs/STRUCTURED-VIEW.md), so two
- * clients racing the same approval never see this reject. */
-export async function resolveStructuredApproval(
-  id: Uuid,
-  nonce: string,
-  decision: StructuredApprovalDecision,
-): Promise<void> {
-  await jsonOrError(
-    await fetch(routes.structuredApproval(id, nonce), {
-      method: "POST",
-      credentials: "same-origin",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify(decision),
-    }),
-  );
-}
-
-export { eventsWsUrl, structuredWsUrl } from "./routes.js";
+export { eventsWsUrl } from "./routes.js";

web/src/attach.ts

@@ -0,0 +1,708 @@
+import { FitAddon } from "@xterm/addon-fit";
+import { WebglAddon } from "@xterm/addon-webgl";
+import { Terminal } from "@xterm/xterm";
+import "@xterm/xterm/css/xterm.css";
+
+import { attachWsUrl } from "./routes.js";
+import { FOCUS_SIDEBAR_EVENT } from "./catalog.js";
+import { CommandSet, defineCommands } from "./commands.js";
+import { escapeHtml } from "./html.js";
+import { INITIAL_RECONNECT_MS, MAX_RECONNECT_MS } from "./reconnect.js";
+import { applyModsToChar, cursorSeq, tildeSeq } from "./keys.js";
+import { requestToggleDrawer } from "./drawer.js";
+import { splitCommand, toolIconSvg } from "./toolIcon.js";
+import type { ClientControl, Uuid } from "./types.js";
+import { WebglPolicy } from "./webglRenderer.js";
+
+// The pane's half of the command registry (#148): plain Escape hands the
+// keyboard back to the session list, the pair to the list's Tab.
+const paneKeys = new CommandSet(
+  defineCommands({
+    "pane.focusList": () => document.dispatchEvent(new CustomEvent(FOCUS_SIDEBAR_EVENT)),
+  }),
+  { preventDefault: false },
+);
+
+/** One budget for the whole page — see webglRenderer.ts for why contexts are
+ *  rationed rather than handed to every connection. */
+const webglPolicy = new WebglPolicy();
+
+/**
+ * A single live attach: an xterm terminal bound to the daemon's attach WebSocket.
+ *
+ * The connection is **decoupled from the UI**: it owns a long-lived WS that
+ * keeps streaming PTY output into the terminal buffer whether or not the view
+ * is currently mounted. The shell moves `el` between the visible content pane
+ * and a hidden cache; `onMount`/`onUnmount` only adjust focus + sizing, never
+ * the connection. Only `dispose()` (eviction, an explicit disconnect, or the
+ * session ending) tears the socket down — so switching away and back is
+ * instant, with scrollback already in place.
+ */
+export interface AttachConnection {
+  readonly sessionId: Uuid;
+  /** The `.attach` element (header + terminal body) to mount into a pane. */
+  readonly el: HTMLElement;
+  /** Becomes the visible view: fit to the pane, focus, sync size.
+   *  `focus: false` mounts without taking the keyboard — what a sidebar
+   *  preview needs, so j/k keeps working while the pane is on screen. */
+  onMount(opts?: { focus?: boolean }): void;
+  /** Parked into the cache: keep streaming, just stop driving focus/resize. */
+  onUnmount(): void;
+  /** Put the keyboard back into this terminal — what leaving the sidebar does. */
+  focusTerminal(): void;
+  /** Type raw bytes straight into the PTY, bypassing the terminal's own key
+   *  handling — the leader's literal Ctrl-K escape hatch
+   *  (docs/COMMAND-BAR.md). */
+  sendInput(data: string): void;
+  /** Fully disconnect: close the WS, dispose the terminal, remove the element. */
+  dispose(): void;
+}
+
+export interface AttachOptions {
+  /** Invoked when the user clicks the view's explicit "disconnect" control. */
+  onRequestClose?: (sessionId: Uuid) => void;
+  /** Invoked when the socket closes on its own — the session ended or the link
+   *  dropped — but NOT on an intentional `dispose()` (eviction / user close). The
+   *  shell uses this to auto-close the pane rather than leave a dead one. */
+  onClosed?: (sessionId: Uuid) => void;
+  /** Invoked when the handshake itself never completed — no retry was
+   *  attempted (see `shouldReconnect`'s `everOpened`). Unlike `onClosed`, this
+   *  is not "the session is gone": it is at least as likely a dormant
+   *  session's `409 not_attachable` caught mid-status-update (#168 review).
+   *  The shell re-renders rather than tearing the pane's leaf out, so a
+   *  dormant session's resume affordance can take over in place. */
+  onNeverAttached?: (sessionId: Uuid) => void;
+  /** Asked on every close: should the socket be retried? The shell answers
+   *  from the catalog — see `shouldRetryClose`. `everOpened` is false when
+   *  this attempt never reached `open`. */
+  shouldReconnect?: (sessionId: Uuid, code: number, everOpened: boolean) => boolean;
+}
+
+/** What the header shows about the session (name / command). Optional — falls
+ * back to a short session id when the session isn't known yet. */
+export interface AttachInfo {
+  name: string;
+  command: string;
+}
+
+/** Header echoes the sidebar: the program becomes its tool icon when we have a
+ * mark for it and stays as its bare name when we do not. Arguments are
+ * dropped, as on the card. */
+function commandFragment(command: string): string {
+  const { tool, program } = splitCommand(command);
+  const icon = tool ? toolIconSvg(tool) : null;
+  const text = icon ? "" : program;
+  return `<span class="at-cmd">${icon ?? ""}${text ? escapeHtml(text) : ""}</span>`;
+}
+
+export function createAttachConnection(
+  sessionId: Uuid,
+  opts: AttachOptions = {},
+  info?: AttachInfo,
+): AttachConnection {
+  const el = document.createElement("div");
+  el.className = "attach";
+  // Useful identity over a bare UUID: name · command. The full id stays in the
+  // tooltip for when you really need it.
+  const titleHtml = info
+    ? `<span class="at-name">${escapeHtml(info.name)}</span>` +
+      (info.command && info.command !== info.name ? commandFragment(info.command) : "")
+    : `session <span class="sid">${escapeHtml(sessionId.slice(0, 8))}</span>`;
+  const titleAttr = info ? `${info.name} · ${info.command}  (${sessionId})` : sessionId;
+  el.innerHTML = `
+    <header class="attach-header">
+      <button type="button" class="btn btn-ghost btn-icon sessions-btn" aria-label="Show sessions" title="Show sessions">☰</button>
+      <span class="attach-title" title="${escapeHtml(titleAttr)}">${titleHtml}</span>
+      <span class="attach-state" data-state="connecting">connecting…</span>
+      <button class="btn btn-ghost btn-icon disconnect" type="button" aria-label="Disconnect" title="Disconnect this session">⏻</button>
+    </header>
+    <div class="attach-body"></div>
+  `;
+
+  const body = el.querySelector(".attach-body") as HTMLDivElement;
+  const stateEl = el.querySelector(".attach-state") as HTMLSpanElement;
+  const disconnectBtn = el.querySelector(".disconnect") as HTMLButtonElement;
+
+  const keybar = buildKeyBar((data) => sendInput(data));
+  el.appendChild(keybar.el);
+
+  const setState = (s: string, kind: "connecting" | "open" | "closed" | "error") => {
+    stateEl.textContent = s;
+    stateEl.dataset.state = kind;
+  };
+
+  // Mobile-only (CSS hides it on desktop, where the sidebar is always in view):
+  // the session list is an off-canvas drawer and this is what opens it.
+  (el.querySelector(".sessions-btn") as HTMLElement).addEventListener("click", () =>
+    requestToggleDrawer(),
+  );
+
+  disconnectBtn.addEventListener("click", () => {
+    opts.onRequestClose?.(sessionId);
+  });
+
+  const term = new Terminal({
+    cursorBlink: true,
+    fontFamily:
+      '"JetBrains Mono", ui-monospace, SFMono-Regular, "SF Mono", Menlo, Consolas, "Liberation Mono", monospace',
+    fontSize: 13,
+    convertEol: false,
+    theme: {
+      // The terminal stays dark in both app themes (convention); colors are
+      // tuned to the maestro palette — signal-green cursor, slate background.
+      background: "#121419",
+      foreground: "#e6e8ec",
+      cursor: "#5fe3a1",
+      cursorAccent: "#121419",
+      selectionBackground: "#2b6b4f",
+    },
+    scrollback: 5000,
+    allowProposedApi: true,
+  });
+  const fit = new FitAddon();
+  term.loadAddon(fit);
+  term.open(body);
+
+  // GPU rendering is scoped to the mounted view, not the connection: acquired
+  // in onMount, released in onUnmount. See webglRenderer.ts.
+  let webgl: WebglAddon | null = null;
+  let dprMedia: MediaQueryList | null = null;
+
+  // The glyph atlas is rasterised for one device pixel ratio. Dragging the
+  // window to a display with a different one (or an Android browser-zoom
+  // change) leaves every cell blurry until the atlas is rebuilt.
+  const onDprChange = () => {
+    try {
+      term.clearTextureAtlas();
+    } catch {
+      // ignore — nothing to rebuild if the renderer already went away
+    }
+    watchDpr();
+  };
+
+  function watchDpr(): void {
+    dprMedia?.removeEventListener("change", onDprChange);
+    dprMedia = null;
+    try {
+      dprMedia = window.matchMedia?.(`(resolution: ${window.devicePixelRatio}dppx)`) ?? null;
+      dprMedia?.addEventListener("change", onDprChange);
+    } catch {
+      // ignore — a browser without `resolution` media queries just keeps the
+      // atlas it has, which is the pre-WebGL behaviour anyway
+    }
+  }
+
+  function releaseWebgl(): void {
+    dprMedia?.removeEventListener("change", onDprChange);
+    dprMedia = null;
+    if (!webgl) return;
+    const addon = webgl;
+    webgl = null;
+    try {
+      addon.dispose(); // xterm falls back to the DOM renderer
+    } catch {
+      // ignore — a lost context can throw on the way out
+    }
+  }
+
+  function acquireWebgl(): void {
+    if (webgl || disposed || !webglPolicy.enabled()) return;
+    try {
+      const addon = new WebglAddon();
+      // Context loss is routine on Android — backgrounding the tab is enough.
+      // Drop back to the DOM renderer, then retry only while the shared budget
+      // allows and this view is still the one on screen.
+      addon.onContextLoss(() => {
+        webglPolicy.noteContextLoss();
+        releaseWebgl();
+        if (mounted) acquireWebgl();
+      });
+      term.loadAddon(addon);
+      webgl = addon;
+      watchDpr();
+    } catch {
+      // Context creation failed outright (no GPU, or the browser is already at
+      // its context cap). Count it like a loss so we stop asking, and stay on
+      // the DOM renderer.
+      webglPolicy.noteContextLoss();
+      webgl = null;
+    }
+  }
+
+  // Plain Escape hands the keyboard back to the session list instead of the
+  // shell/app. `false` tells xterm to skip its own handling of this event —
+  // which is also why the set doesn't `preventDefault`: swallowing here is
+  // xterm's return value, not the browser's.
+  term.attachCustomKeyEventHandler((e) => {
+    if (e.type !== "keydown") return true;
+    return !paneKeys.handle(e);
+  });
+
+  // Touch scrolling: xterm's built-in touch handling is jittery (drags crawl a
+  // line at a time and stall), so map finger drags ourselves. Two routes:
+  //   • normal buffer  → term.scrollLines walks the scrollback.
+  //   • mouse-tracking apps (tmux, Claude Code on the alt screen) → synthesize
+  //     wheel events so xterm encodes them as mouse-wheel reports the app reads,
+  //     scrolling *its* content (the only scroll that exists on the alt screen).
+  //   • alt screen with no mouse tracking → nothing to do; the app owns input.
+  // `touch-action: none` (CSS) keeps the browser from cancelling the custom
+  // gesture stream; only the terminal surface opts out of native page panning.
+  // Listeners MUST sit on `.xterm`, not `.xterm-viewport`: `.xterm-screen` is a
+  // later sibling of the viewport, so it paints over it and takes every touch.
+  {
+    const root = term.element as HTMLElement | undefined;
+    const screen = el.querySelector(".xterm-screen") as HTMLElement | null;
+    const cellH = () => {
+      const core = (term as unknown as {
+        _core?: { _renderService?: { dimensions?: { css?: { cell?: { height: number } } } } };
+      })._core;
+      return core?._renderService?.dimensions?.css?.cell?.height || 16;
+    };
+    if (root) {
+      let lastY = 0;
+      let lastX = 0;
+      let remainder = 0;
+      root.addEventListener(
+        "touchstart",
+        (e) => {
+          if (e.touches.length !== 1) return;
+          lastY = e.touches[0].clientY;
+          lastX = e.touches[0].clientX;
+          remainder = 0;
+        },
+        { passive: true },
+      );
+      root.addEventListener(
+        "touchmove",
+        (e) => {
+          if (e.touches.length !== 1) return;
+          const ch = cellH();
+          const y = e.touches[0].clientY;
+          const px = lastY - y + remainder; // finger up → scroll toward newer
+          lastY = y;
+          const lines = Math.trunc(px / ch);
+          remainder = px - lines * ch;
+          if (lines === 0) return;
+          // term.modes.mouseTrackingMode is "none" unless the app turned mouse
+          // reporting on — that's the signal to forward instead of scrollback.
+          const mouseTracked = term.modes.mouseTrackingMode !== "none";
+          if (mouseTracked && screen) {
+            // One wheel event per crossed cell, dispatched at the touch point so
+            // xterm computes valid cell coords for the mouse report.
+            const dir = lines > 0 ? 1 : -1;
+            for (let i = 0; i < Math.abs(lines); i++) {
+              screen.dispatchEvent(
+                new WheelEvent("wheel", {
+                  deltaY: dir * ch,
+                  deltaMode: 0,
+                  clientX: lastX,
+                  clientY: y,
+                  bubbles: true,
+                  cancelable: true,
+                }),
+              );
+            }
+            e.preventDefault();
+          } else if (term.buffer.active.type !== "alternate") {
+            term.scrollLines(lines);
+            e.preventDefault();
+          }
+        },
+        { passive: false },
+      );
+    }
+  }
+
+  // Mobile: the special-key bar is only useful while the soft keyboard is up,
+  // so reveal it only when the terminal's hidden textarea is focused (CSS still
+  // gates it to coarse pointers). Tapping a keycap keeps focus via pointerdown
+  // preventDefault, so the bar stays put during use. Re-fit on the toggle since
+  // showing/hiding the bar changes the terminal's available height.
+  const ta = term.textarea;
+  if (ta) {
+    ta.addEventListener("focus", () => {
+      keybar.el.classList.add("keybar-active");
+      requestAnimationFrame(tryFit);
+    });
+    ta.addEventListener("blur", () => {
+      keybar.el.classList.remove("keybar-active");
+      requestAnimationFrame(tryFit);
+    });
+  }
+
+  let mounted = false;
+  // A previewed pane is visible but must not steal the keyboard from the
+  // sidebar, so mounting can opt out of the focus grab (and out of the one
+  // the socket does when it finishes connecting).
+  let focusOnMount = true;
+  // We compute the fit ourselves instead of FitAddon.fit(): the addon subtracts
+  // a scrollbar width that xterm reports as `offsetWidth - scrollArea || 15`,
+  // so with the scrollbar hidden it falls back to a phantom 15px and the grid
+  // stops ~1–2 columns short of the edge. Same math, minus that subtraction.
+  const tryFit = () => {
+    if (!mounted) return; // parked views have no meaningful size to fit to
+    try {
+      const el2 = term.element;
+      const parent = el2?.parentElement;
+      const core = (term as unknown as {
+        _core?: { _renderService?: { dimensions?: { css?: { cell?: { width: number; height: number } } } } };
+      })._core;
+      const cell = core?._renderService?.dimensions?.css?.cell;
+      if (!el2 || !parent || !cell || !cell.width || !cell.height) {
+        fit.fit(); // fall back if internals aren't ready yet
+        return;
+      }
+      // Measure the viewport's real inner width (clientWidth excludes any
+      // scrollbar), not the container's — so columns always fit inside the
+      // viewport whether or not xterm reserves a scrollbar. Falls back to the
+      // padded container box before the viewport exists.
+      const vp = el2.querySelector(".xterm-viewport") as HTMLElement | null;
+      let availW: number;
+      let availH: number;
+      if (vp && vp.clientWidth > 0) {
+        availW = vp.clientWidth;
+        availH = vp.clientHeight;
+      } else {
+        const ps = getComputedStyle(parent);
+        const ts = getComputedStyle(el2);
+        availW =
+          parseInt(ps.width) -
+          (parseInt(ts.paddingLeft) + parseInt(ts.paddingRight) || 0);
+        availH =
+          parseInt(ps.height) -
+          (parseInt(ts.paddingTop) + parseInt(ts.paddingBottom) || 0);
+      }
+      const cols = Math.max(2, Math.floor(availW / cell.width));
+      const rows = Math.max(1, Math.floor(availH / cell.height));
+      if (cols !== term.cols || rows !== term.rows) term.resize(cols, rows);
+    } catch {
+      try {
+        fit.fit();
+      } catch {
+        // ignore — fit fails if the container is detached or zero-sized
+      }
+    }
+  };
+
+  let ws: WebSocket;
+  let reconnectMs = INITIAL_RECONNECT_MS;
+  let reconnectTimer: number | null = null;
+  // #168 review: a fresh attempt that never reaches `open` is a rejected
+  // handshake (dormant/unknown session), not a dropped stream — see
+  // `shouldRetryClose`'s `everOpened` param.
+  let everOpened = false;
+
+  const sendControl = (msg: ClientControl) => {
+    if (ws.readyState !== WebSocket.OPEN) return;
+    ws.send(JSON.stringify(msg));
+  };
+
+  /** PTY input: raw bytes out as a binary frame. Shared by keystrokes and the
+   *  mobile key bar so both flow through the same path. */
+  const sendInput = (data: string) => {
+    if (ws.readyState !== WebSocket.OPEN) return;
+    ws.send(new TextEncoder().encode(data));
+  };
+
+  const onResize = () => {
+    tryFit();
+    sendControl({ type: "Resize", cols: term.cols, rows: term.rows });
+  };
+
+  function connect(): void {
+    ws = new WebSocket(attachWsUrl(sessionId));
+    ws.binaryType = "arraybuffer";
+
+    ws.onopen = () => {
+      everOpened = true;
+      reconnectMs = INITIAL_RECONNECT_MS;
+      setState("connected", "open");
+      sendControl({ type: "Resize", cols: term.cols, rows: term.rows });
+      if (mounted && focusOnMount) term.focus();
+    };
+
+    ws.onmessage = (ev) => {
+      if (typeof ev.data === "string") {
+        try {
+          JSON.parse(ev.data) as ClientControl;
+        } catch {
+          // ignore unknown control frames
+        }
+        return;
+      }
+      if (ev.data instanceof ArrayBuffer) {
+        term.write(new Uint8Array(ev.data));
+      } else if (ev.data instanceof Blob) {
+        // Some browsers may default to Blob despite binaryType="arraybuffer".
+        ev.data.arrayBuffer().then((b) => term.write(new Uint8Array(b)));
+      }
+    };
+
+    ws.onerror = () => {
+      setState("error", "error");
+    };
+
+    ws.onclose = (ev) => {
+      // The web proxy relays a daemon rejection (unknown session) as an
+      // application close code (4000+) carrying a human reason. Show it in the
+      // pane — both the header and the terminal body — and KEEP the pane up so
+      // the user can read why, instead of letting it flash and vanish (#39).
+      const reason = ev.reason?.trim();
+      if (ev.code >= 4000 && reason && !disposed) {
+        setState(reason, "error");
+        term.write(`\r\n\x1b[31m⚠ cannot attach: ${reason}\x1b[0m\r\n`);
+        return;
+      }
+      // An intentional dispose has already set `disposed`; eviction and user
+      // close handle their own pane teardown.
+      if (disposed) return;
+
+      if (opts.shouldReconnect?.(sessionId, ev.code, everOpened)) {
+        const delay = Math.min(reconnectMs, MAX_RECONNECT_MS);
+        setState("reconnecting…", "connecting");
+        reconnectTimer = window.setTimeout(() => {
+          reconnectTimer = null;
+          reconnectMs = Math.min(reconnectMs * 2, MAX_RECONNECT_MS);
+          connect();
+        }, delay);
+        return;
+      }
+
+      if (!everOpened) {
+        setState("not attached", "closed");
+        opts.onNeverAttached?.(sessionId);
+        return;
+      }
+
+      setState(`closed (${ev.code})`, "closed");
+      opts.onClosed?.(sessionId);
+    };
+  }
+
+  connect();
+
+  // PTY input: every keystroke goes out as a binary frame. A pending key-bar
+  // Ctrl modifier (mobile) folds into the next typed character here.
+  const dataDisp = term.onData((data) => {
+    sendInput(keybar.consume(data));
+  });
+  const resizeDisp = term.onResize(({ cols, rows }) => {
+    sendControl({ type: "Resize", cols, rows });
+  });
+
+  window.addEventListener("resize", onResize);
+  const visual = window.visualViewport ?? null;
+  visual?.addEventListener("resize", onResize);
+
+  // FitAddon only recomputes on the events we call it from — a window resize
+  // misses container-driven changes (sidebar drag, mobile layout settling,
+  // orientation, late font load). Observe the body directly so columns always
+  // match the real rendered width and the terminal fills edge to edge.
+  const ro = new ResizeObserver(() => tryFit());
+  ro.observe(body);
+  // Re-fit once the monospace font is actually loaded — cell width changes when
+  // the fallback is swapped out, which otherwise leaves stale columns.
+  document.fonts?.ready?.then(() => tryFit()).catch(() => {});
+
+  let disposed = false;
+
+  return {
+    sessionId,
+    el,
+    onMount(mountOpts?: { focus?: boolean }) {
+      mounted = true;
+      focusOnMount = mountOpts?.focus !== false;
+      acquireWebgl();
+      // Defer a tick so the element has its content-pane dimensions before fit.
+      requestAnimationFrame(() => {
+        tryFit();
+        sendControl({ type: "Resize", cols: term.cols, rows: term.rows });
+        if (focusOnMount && ws.readyState === WebSocket.OPEN) term.focus();
+      });
+    },
+    onUnmount() {
+      mounted = false;
+      // Parked views hand their GPU context back: the browser's cap is small
+      // (smaller still on Android) and MAX_PARKED connections outlive the pane.
+      releaseWebgl();
+    },
+    focusTerminal() {
+      term.focus();
+    },
+    // The closure above: the same bytes-out path keystrokes and the mobile key
+    // bar already take.
+    sendInput,
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      if (reconnectTimer !== null) {
+        window.clearTimeout(reconnectTimer);
+        reconnectTimer = null;
+      }
+      ro.disconnect();
+      window.removeEventListener("resize", onResize);
+      visual?.removeEventListener("resize", onResize);
+      dataDisp.dispose();
+      resizeDisp.dispose();
+      releaseWebgl();
+      try {
+        ws.close();
+      } catch {
+        // ignore
+      }
+      term.dispose();
+      el.remove();
+    },
+  };
+}
+
+/**
+ * One key in the mobile key bar.
+ * - `mod` is a sticky one-shot modifier toggle (Ctrl / Alt).
+ * - `cursor` is a cursor/navigation key, identified by its CSI final byte, so a
+ *   pending modifier can promote it to the `\x1b[1;<n><final>` form.
+ * - `tilde` is a `~`-terminated navigation key (PgUp/PgDn), identified by its
+ *   CSI parameter, whose modified form is `\x1b[<code>;<n>~`.
+ * - `char` is a literal character (the symbols the soft keyboard buries behind
+ *   a page switch), folded through a pending modifier like typed input.
+ * - `seq` is a plain key (Esc, Tab) sent verbatim.
+ */
+type KeyDef =
+  | { label: string; mod: Modifier }
+  | { label: string; cursor: CursorFinal }
+  | { label: string; tilde: number }
+  | { label: string; char: string }
+  | { label: string; seq: string };
+
+type Modifier = "ctrl" | "alt";
+/** CSI final bytes: arrows A–D, Home `H`, End `F`. */
+type CursorFinal = "A" | "B" | "C" | "D" | "H" | "F";
+
+/**
+ * The keys the mobile soft keyboard hides, ordered to flow row-major into an
+ * 8-column / 2-row grid (#7):
+ *
+ *     Esc  Tab  Home  ↑   End  PgUp  -  /
+ *     Ctrl Alt   ←    ↓    →   PgDn  |  ~
+ *
+ * — Esc/Tab + the Ctrl/Alt sticky modifiers on the left, the cursor keys as a
+ * real-keyboard inverted-T in the middle with Home/End filling its top corners,
+ * then the paging pair and the shell symbols that cost a soft-keyboard page
+ * switch to reach. Narrower screens scroll the bar sideways rather than
+ * shrinking the caps below a thumb's width.
+ */
+const KEY_DEFS: KeyDef[] = [
+  { label: "Esc", seq: "\x1b" },
+  { label: "Tab", seq: "\t" },
+  { label: "Home", cursor: "H" },
+  { label: "↑", cursor: "A" },
+  { label: "End", cursor: "F" },
+  { label: "PgUp", tilde: 5 },
+  { label: "-", char: "-" },
+  { label: "/", char: "/" },
+  { label: "Ctrl", mod: "ctrl" },
+  { label: "Alt", mod: "alt" },
+  { label: "←", cursor: "D" },
+  { label: "↓", cursor: "B" },
+  { label: "→", cursor: "C" },
+  { label: "PgDn", tilde: 6 },
+  { label: "|", char: "|" },
+  { label: "~", char: "~" },
+];
+
+/**
+ * Fold a single character into its control code: letters and `@[\]^_` map to
+ * 0x00–0x1f, space → NUL, `?` → DEL. Anything else is returned unchanged.
+ */
+interface KeyBar {
+  readonly el: HTMLElement;
+  /** Fold pending modifiers into typed input (soft keyboard), consuming them. */
+  consume(data: string): string;
+}
+
+/**
+ * Build the Termux-style special-key bar. Hidden by default; CSS reveals it on
+ * coarse-pointer (touch) devices. `send` delivers bytes to the PTY.
+ *
+ * Ctrl and Alt are one-shot sticky modifiers: arm them and the very next key —
+ * tapped here or typed on the soft keyboard — carries the modifier, then they
+ * disarm. Taps `preventDefault` on pointerdown so the terminal keeps focus and
+ * the keyboard stays open.
+ */
+function buildKeyBar(send: (data: string) => void): KeyBar {
+  const el = document.createElement("div");
+  el.className = "attach-keybar";
+  el.setAttribute("role", "toolbar");
+  el.setAttribute("aria-label", "Special keys");
+
+  const armed: Record<Modifier, boolean> = { ctrl: false, alt: false };
+  const modBtns: Partial<Record<Modifier, HTMLButtonElement>> = {};
+
+  const setMod = (mod: Modifier, on: boolean) => {
+    armed[mod] = on;
+    modBtns[mod]?.setAttribute("aria-pressed", String(on));
+  };
+  const clearMods = () => {
+    setMod("ctrl", false);
+    setMod("alt", false);
+  };
+
+  for (const def of KEY_DEFS) {
+    const btn = document.createElement("button");
+    btn.type = "button";
+    btn.className = "keycap";
+    btn.textContent = def.label;
+
+    if ("mod" in def) {
+      btn.classList.add("keycap-mod");
+      btn.setAttribute("aria-pressed", "false");
+      btn.setAttribute("aria-label", `${def.label} modifier`);
+      modBtns[def.mod] = btn;
+      btn.addEventListener("click", () => setMod(def.mod, !armed[def.mod]));
+    } else if ("cursor" in def) {
+      btn.addEventListener("click", () => {
+        send(cursorSeq(def.cursor, armed.ctrl, armed.alt));
+        clearMods();
+      });
+    } else if ("tilde" in def) {
+      btn.addEventListener("click", () => {
+        send(tildeSeq(def.tilde, armed.ctrl, armed.alt));
+        clearMods();
+      });
+    } else if ("char" in def) {
+      btn.addEventListener("click", () => {
+        send(applyModsToChar(def.char, armed.ctrl, armed.alt));
+        clearMods();
+      });
+    } else {
+      btn.addEventListener("click", () => {
+        send(def.seq);
+        clearMods();
+      });
+    }
+
+    // Keep the terminal focused (soft keyboard up) — don't let the tap steal it.
+    // preventDefault suppresses the native `:active` style, so flash an explicit
+    // press animation here for tactile feedback.
+    btn.addEventListener("pointerdown", (e) => {
+      e.preventDefault();
+      btn.classList.remove("is-pressed");
+      void btn.offsetWidth; // restart the animation if re-tapped mid-flash
+      btn.classList.add("is-pressed");
+    });
+    btn.addEventListener("animationend", () => btn.classList.remove("is-pressed"));
+    el.appendChild(btn);
+  }
+
+  return {
+    el,
+    consume(data: string): string {
+      if ((armed.ctrl || armed.alt) && data.length === 1) {
+        const out = applyModsToChar(data, armed.ctrl, armed.alt);
+        clearMods();
+        return out;
+      }
+      return data;
+    },
+  };
+}

web/src/barActions.test.ts

@@ -0,0 +1,139 @@
+// @vitest-environment happy-dom
+//
+// The sidebar's half of the command bar's action page (#151): the bar picks
+// kill or rename and raises the flow the card already has, so what the page
+// runs is what the ✕ button and the `r` key run.
+import { afterEach, beforeAll, describe, expect, it } from "vitest";
+
+import { KILL_SESSION_EVENT, RENAME_SESSION_EVENT, renderSidebar } from "./catalog.js";
+import type { CatalogListener, CatalogStore } from "./events.js";
+import type { Session } from "./types.js";
+
+beforeAll(() => {
+  Object.defineProperty(window, "localStorage", {
+    value: { getItem: () => null, setItem: () => {} },
+  });
+});
+
+let mounted: { el: HTMLElement; dispose: () => void } | null = null;
+
+afterEach(() => {
+  document.querySelector(".kill-dialog")?.remove();
+  mounted?.dispose();
+  mounted = null;
+  document.body.replaceChildren();
+});
+
+function session(overrides: Partial<Session> = {}): Session {
+  return {
+    id: "aaaaaaaa-0000-0000-0000-0000000000ff",
+    cwd: "/home/naps/tea/maestro",
+    command: "claude",
+    env: {},
+    metadata: { name: "amber-falcon" },
+    status: "Running",
+    created_at: "2026-08-24T10:00:00Z",
+    ...overrides,
+  };
+}
+
+function storeWith(sessions: Session[]): CatalogStore {
+  const state = { sessions: new Map(sessions.map((s) => [s.id, s])) };
+  return {
+    snapshot: () => state,
+    subscribe: (fn: CatalogListener) => {
+      fn(state);
+      return () => {};
+    },
+  } as unknown as CatalogStore;
+}
+
+function mount(s: Session): HTMLElement {
+  const handle = renderSidebar(storeWith([s]));
+  mounted = handle;
+  document.body.appendChild(handle.el);
+  return handle.el;
+}
+
+function raise(name: string, s: Session): void {
+  document.dispatchEvent(new CustomEvent(name, { detail: s }));
+}
+
+/** Let the kill chain's awaits (fetch, its json body) settle. */
+async function flush(): Promise<void> {
+  for (let i = 0; i < 8; i++) await Promise.resolve();
+}
+
+describe("kill from the action page", () => {
+  it("goes through the same confirmation the sidebar raises (#160)", async () => {
+    const calls: string[] = [];
+    window.fetch = ((url: string, init?: RequestInit) => {
+      calls.push(`${init?.method ?? "GET"} ${url}`);
+      return Promise.resolve(new Response(null, { status: 204 }));
+    }) as typeof fetch;
+    const s = session();
+    mount(s);
+    raise(KILL_SESSION_EVENT, s);
+    await flush();
+    expect(document.querySelector(".kill-dialog")?.getAttribute("aria-label")).toBe(
+      "Kill amber-falcon",
+    );
+    expect(calls.filter((c) => c.startsWith("DELETE"))).toHaveLength(0);
+    document.querySelector<HTMLButtonElement>(".kill-dialog-kill")?.click();
+    await flush();
+    expect(calls).toContain(`DELETE /api/sessions/${s.id}`);
+    expect(document.querySelector(".kill-dialog")).toBeNull();
+  });
+
+  it("raises the existing confirm-and-blockers dialog on a guarded refusal", async () => {
+    window.fetch = ((url: string) => {
+      if (String(url).includes("force=true")) {
+        return Promise.resolve(new Response(null, { status: 204 }));
+      }
+      return Promise.resolve(
+        new Response(
+          JSON.stringify({
+            error: {
+              code: "kill_guarded",
+              message: "worktree has unsaved work",
+              unsaved_work: { untracked_files: 1 },
+            },
+          }),
+          { status: 409, headers: { "content-type": "application/json" } },
+        ),
+      );
+    }) as typeof fetch;
+    const s = session({ blocked_work: { untracked_files: 1 } });
+    mount(s);
+    raise(KILL_SESSION_EVENT, s);
+    await flush();
+    document.querySelector<HTMLButtonElement>(".kill-dialog-kill")?.click();
+    await flush();
+    const dialog = document.querySelector(".kill-dialog");
+    expect(dialog?.getAttribute("aria-label")).toBe("Kill amber-falcon");
+    expect(dialog?.textContent).toContain("1 untracked file");
+  });
+});
+
+describe("rename from the action page", () => {
+  it("expands the folder hiding the card, since the prompt lives in the card", () => {
+    window.fetch = (() => Promise.reject(new Error("offline"))) as typeof fetch;
+    const s = session();
+    const el = mount(s);
+    const folder = el.querySelector<HTMLElement>(".tree-folder-header");
+    folder?.click();
+    expect(el.querySelector(`[data-session-id="${s.id}"]`)).toBeNull();
+    raise(RENAME_SESSION_EVENT, s);
+    expect(el.querySelector<HTMLInputElement>(".leaf-rename")?.value).toBe("amber-falcon");
+  });
+
+  it("raises the card's own prompt, pre-filled with the session's name", () => {
+    window.fetch = (() => Promise.reject(new Error("offline"))) as typeof fetch;
+    const s = session();
+    const el = mount(s);
+    raise(RENAME_SESSION_EVENT, s);
+    const input = el.querySelector<HTMLInputElement>(".leaf-rename");
+    expect(input?.value).toBe("amber-falcon");
+    expect(input?.getAttribute("aria-label")).toBe("Rename amber-falcon");
+  });
+});

web/src/catalog.test.ts

@@ -0,0 +1,491 @@
+// @vitest-environment happy-dom
+import { afterEach, beforeAll, describe, expect, it } from "vitest";
+
+import { renderSidebar } from "./catalog.js";
+import type { CatalogListener, CatalogStore } from "./events.js";
+import type { InTheWay, Session } from "./types.js";
+
+// happy-dom runs without a backing store; renderSidebar reads the persisted
+// sidebar width on mount.
+beforeAll(() => {
+  Object.defineProperty(window, "localStorage", {
+    value: { getItem: () => null, setItem: () => {} },
+  });
+  // No daemon here; renderSidebar treats a failed info fetch as "absolute
+  // paths are a fine fallback".
+  window.fetch = () => Promise.reject(new Error("offline"));
+});
+
+afterEach(() => {
+  document.querySelector(".kill-dialog")?.remove();
+});
+
+function session(overrides: Partial<Session>): Session {
+  return {
+    id: "11111111-2222-3333-4444-555555555555",
+    cwd: "/home/naps/tea/maestro",
+    command: "claude",
+    env: {},
+    metadata: {},
+    status: "Running",
+    created_at: "2026-08-24T10:00:00Z",
+    ...overrides,
+  };
+}
+
+function storeWith(sessions: Session[]): CatalogStore {
+  const state = { sessions: new Map(sessions.map((s) => [s.id, s])) };
+  return {
+    snapshot: () => state,
+    // Like the real store, deliver an immediate snapshot so the sidebar
+    // renders its rows during construction.
+    subscribe: (fn: CatalogListener) => {
+      fn(state);
+      return () => {};
+    },
+  } as unknown as CatalogStore;
+}
+
+function rowFor(el: HTMLElement, id: string): HTMLElement | null {
+  return el.querySelector<HTMLElement>(`[data-session-id="${id}"]`);
+}
+
+/** Let the kill chain's awaits (fetch, its json body) settle. */
+async function flush(): Promise<void> {
+  for (let i = 0; i < 8; i++) await Promise.resolve();
+}
+
+describe("blocked-work indicator (#83)", () => {
+  it("marks the row of a blocked session in diff notation", () => {
+    const blocked = session({
+      id: "aaaaaaaa-0000-0000-0000-000000000001",
+      blocked_work: {
+        uncommitted_files: 3,
+        unpushed_commits: 2,
+        insertions: 124,
+        deletions: 18,
+      },
+    });
+    const el = renderSidebar(storeWith([blocked])).el;
+    const badge = rowFor(el, blocked.id)?.querySelector(".leaf-blocked");
+    expect(badge?.textContent).toBe("+124-18↑2");
+    // The spelled-out breakdown survives in the tooltip.
+    expect(badge?.getAttribute("title")).toContain(
+      "3 uncommitted files, 2 unpushed commits",
+    );
+  });
+
+  it("falls back to the file count when tracked changes carry no lines", () => {
+    const blocked = session({
+      id: "aaaaaaaa-0000-0000-0000-00000000001a",
+      blocked_work: { uncommitted_files: 2, untracked_files: 1 },
+    });
+    const el = renderSidebar(storeWith([blocked])).el;
+    const badge = rowFor(el, blocked.id)?.querySelector(".leaf-blocked");
+    expect(badge?.textContent).toBe("~2?1");
+  });
+
+  it("does not mark clear or unprobed sessions", () => {
+    const clear = session({
+      id: "aaaaaaaa-0000-0000-0000-000000000002",
+      blocked_work: {} as InTheWay,
+    });
+    const unprobed = session({
+      id: "aaaaaaaa-0000-0000-0000-000000000003",
+    });
+    const el = renderSidebar(storeWith([clear, unprobed])).el;
+    expect(rowFor(el, clear.id)?.querySelector(".leaf-blocked")).toBeNull();
+    expect(rowFor(el, unprobed.id)?.querySelector(".leaf-blocked")).toBeNull();
+  });
+
+  it("confirms before an unguarded kill (#160)", async () => {
+    const calls: string[] = [];
+    window.fetch = ((url: string, init?: RequestInit) => {
+      calls.push(`${init?.method ?? "GET"} ${url}`);
+      return Promise.resolve(new Response(null, { status: 204 }));
+    }) as typeof fetch;
+    const plain = session({ id: "aaaaaaaa-0000-0000-0000-000000000005" });
+    const el = renderSidebar(storeWith([plain])).el;
+    rowFor(el, plain.id)?.querySelector<HTMLButtonElement>(".leaf-kill")?.click();
+    await flush();
+    const dialog = document.querySelector(".kill-dialog");
+    expect(dialog?.getAttribute("aria-label")).toBe("Kill claude");
+    expect(calls.filter((c) => c.startsWith("DELETE"))).toHaveLength(0);
+    dialog?.querySelector<HTMLButtonElement>(".kill-dialog-kill")?.click();
+    await flush();
+    expect(calls).toContain(`DELETE /api/sessions/${plain.id}`);
+    expect(document.querySelector(".kill-dialog")).toBeNull();
+  });
+
+  it("kills nothing when the confirmation is cancelled (#160)", async () => {
+    const calls: string[] = [];
+    window.fetch = ((url: string, init?: RequestInit) => {
+      calls.push(`${init?.method ?? "GET"} ${url}`);
+      return Promise.resolve(new Response(null, { status: 204 }));
+    }) as typeof fetch;
+    const plain = session({ id: "aaaaaaaa-0000-0000-0000-000000000007" });
+    const el = renderSidebar(storeWith([plain])).el;
+    rowFor(el, plain.id)?.querySelector<HTMLButtonElement>(".leaf-kill")?.click();
+    await flush();
+    document.querySelector<HTMLButtonElement>(".kill-dialog-cancel")?.click();
+    await flush();
+    expect(document.querySelector(".kill-dialog")).toBeNull();
+    expect(calls.filter((c) => c.startsWith("DELETE"))).toHaveLength(0);
+  });
+
+  it("names the blockers in the confirmation, before the daemon refuses (#160)", async () => {
+    window.fetch = (() => Promise.reject(new Error("never called"))) as typeof fetch;
+    const blocked = session({
+      id: "aaaaaaaa-0000-0000-0000-000000000008",
+      blocked_work: { untracked_files: 1 },
+    });
+    const el = renderSidebar(storeWith([blocked])).el;
+    rowFor(el, blocked.id)?.querySelector<HTMLButtonElement>(".leaf-kill")?.click();
+    await flush();
+    const dialog = document.querySelector(".kill-dialog");
+    expect(dialog?.textContent).toContain("1 untracked file");
+    expect(dialog?.textContent).toContain("refused unless it is forced");
+  });
+
+  it("offers the override when the daemon refuses a guarded kill", async () => {
+    const calls: string[] = [];
+    window.fetch = ((url: string, init?: RequestInit) => {
+      calls.push(`${init?.method ?? "GET"} ${url}`);
+      if (url.includes("force=true")) return Promise.resolve(new Response(null, { status: 204 }));
+      return Promise.resolve(
+        new Response(
+          JSON.stringify({
+            error: {
+              code: "kill_guarded",
+              message: "worktree has unsaved work",
+              unsaved_work: { untracked_files: 1 },
+            },
+          }),
+          { status: 409, headers: { "content-type": "application/json" } },
+        ),
+      );
+    }) as typeof fetch;
+    const blocked = session({
+      id: "aaaaaaaa-0000-0000-0000-000000000004",
+      command: "bash",
+      blocked_work: { untracked_files: 1 },
+    });
+    const el = renderSidebar(storeWith([blocked])).el;
+    rowFor(el, blocked.id)?.querySelector<HTMLButtonElement>(".leaf-kill")?.click();
+    await flush();
+    document.querySelector<HTMLButtonElement>(".kill-dialog-kill")?.click();
+    await flush();
+    const dialog = document.querySelector(".kill-dialog");
+    expect(dialog?.textContent).toContain("1 untracked file");
+    dialog?.querySelector<HTMLButtonElement>(".kill-dialog-force")?.click();
+    await flush();
+    expect(calls).toContain(`DELETE /api/sessions/${blocked.id}?force=true`);
+    expect(document.querySelector(".kill-dialog")).toBeNull();
+  });
+
+  it("closes the override prompt without killing on cancel", async () => {
+    const calls: string[] = [];
+    window.fetch = ((url: string, init?: RequestInit) => {
+      calls.push(`${init?.method ?? "GET"} ${url}`);
+      return Promise.resolve(
+        new Response(
+          JSON.stringify({
+            error: { code: "kill_guarded", message: "worktree has unsaved work" },
+          }),
+          { status: 409, headers: { "content-type": "application/json" } },
+        ),
+      );
+    }) as typeof fetch;
+    const blocked = session({
+      id: "aaaaaaaa-0000-0000-0000-000000000006",
+      blocked_work: { unpushed_commits: 2 },
+    });
+    const el = renderSidebar(storeWith([blocked])).el;
+    rowFor(el, blocked.id)?.querySelector<HTMLButtonElement>(".leaf-kill")?.click();
+    await flush();
+    document.querySelector<HTMLButtonElement>(".kill-dialog-kill")?.click();
+    await flush();
+    document.querySelector<HTMLButtonElement>(".kill-dialog-cancel")?.click();
+    expect(document.querySelector(".kill-dialog")).toBeNull();
+    expect(calls.filter((c) => c.includes("force=true"))).toHaveLength(0);
+  });
+});
+
+describe("agent-reported detail (#112)", () => {
+  const ago = (ms: number): string => new Date(Date.now() - ms).toISOString();
+
+  it("renders the reported detail right after the duration on line 2", () => {
+    const s = session({
+      id: "aaaaaaaa-0000-0000-0000-000000000020",
+      status: "Dead",
+      activity: "Error",
+      activity_since: ago(90_000),
+      activity_detail: "cargo build failed",
+    });
+    const el = renderSidebar(storeWith([s])).el;
+    const line2 = rowFor(el, s.id)?.querySelector<HTMLElement>(".card-line2");
+    expect(line2?.querySelector(".activity-detail")?.textContent).toBe("cargo build failed");
+    const order = [...line2!.children].map((c) => c.className);
+    expect(order.indexOf("activity-detail")).toBeGreaterThan(order.indexOf("activity-duration"));
+    expect(order.indexOf("activity-detail")).toBeLessThan(
+      order.findIndex((c) => c.startsWith("card-flag")),
+    );
+  });
+
+  it("omits the detail when no report is in force", () => {
+    const s = session({
+      id: "aaaaaaaa-0000-0000-0000-000000000021",
+      activity: "Active",
+      activity_since: ago(90_000),
+    });
+    const el = renderSidebar(storeWith([s])).el;
+    expect(rowFor(el, s.id)?.querySelector(".activity-detail")).toBeNull();
+  });
+});
+
+describe("session cards (#107)", () => {
+  const ago = (ms: number): string => new Date(Date.now() - ms).toISOString();
+
+  it("keeps the name and the actions in the same flow line, actions reserving their width", () => {
+    const s = session({ id: "aaaaaaaa-0000-0000-0000-000000000010" });
+    const el = renderSidebar(storeWith([s])).el;
+    const line1 = rowFor(el, s.id)?.querySelector<HTMLElement>(".card-line1");
+    expect(line1).not.toBeNull();
+    // Same flex line ⇒ the name truncates before it can ever reach the buttons.
+    expect(line1?.querySelector(".leaf-name")).not.toBeNull();
+    expect(line1?.querySelector(".leaf-actions")).toBe(line1?.lastElementChild);
+  });
+
+  it("always renders line 2 for a freshly spawned session", () => {
+    const s = session({
+      id: "aaaaaaaa-0000-0000-0000-000000000011",
+      activity: "Active",
+      activity_since: ago(5_000),
+    });
+    const el = renderSidebar(storeWith([s])).el;
+    const row = rowFor(el, s.id);
+    const line2 = row?.querySelector<HTMLElement>(".card-line2");
+    expect(line2).not.toBeNull();
+    expect(row?.querySelector(".activity-rail")).not.toBeNull();
+    expect(line2?.querySelector(".activity-duration")).toBeNull();
+    expect(line2?.querySelector(".leaf-cmd")).not.toBeNull();
+  });
+
+  it("shows dot + floored duration once the state has been held past 30s", () => {
+    const s = session({
+      id: "aaaaaaaa-0000-0000-0000-000000000012",
+      activity: "Active",
+      activity_since: ago(4 * 60_000 + 30_000),
+    });
+    const el = renderSidebar(storeWith([s])).el;
+    const row = rowFor(el, s.id);
+    const line2 = row?.querySelector<HTMLElement>(".card-line2");
+    expect(line2?.dataset.activity).toBe("active");
+    expect(row?.querySelector(".activity-rail")).not.toBeNull();
+    expect(line2?.querySelector(".activity-duration")?.textContent).toBe("4m");
+  });
+
+  it("dims a name the daemon generated, until it settles (#131)", () => {
+    const generated = session({
+      id: "aaaaaaaa-0000-0000-0000-0000000000a1",
+      metadata: { name: "amber-falcon", name_source: "Generated" },
+    });
+    const haiku = session({
+      id: "aaaaaaaa-0000-0000-0000-0000000000a2",
+      metadata: { name: "sidebar-rail", name_source: "Haiku" },
+    });
+    const chosen = session({
+      id: "aaaaaaaa-0000-0000-0000-0000000000a3",
+      metadata: { name: "my-session", name_source: "User" },
+    });
+    // Named before `name_source` existed: settled, never dimmed.
+    const legacy = session({
+      id: "aaaaaaaa-0000-0000-0000-0000000000a4",
+      metadata: { name: "older-session" },
+    });
+
+    const el = renderSidebar(storeWith([generated, haiku, chosen, legacy])).el;
+    const provisional = (s: Session) =>
+      rowFor(el, s.id)?.querySelector(".leaf-name")?.classList.contains("is-provisional");
+    expect(provisional(generated)).toBe(true);
+    expect(provisional(haiku)).toBe(false);
+    expect(provisional(chosen)).toBe(false);
+    expect(provisional(legacy)).toBe(false);
+  });
+
+  it("renders the command as its tool icon when the tool is known", () => {
+    const s = session({
+      id: "aaaaaaaa-0000-0000-0000-00000000001b",
+      command: "claude",
+      metadata: { name: "claude" },
+    });
+    const el = renderSidebar(storeWith([s])).el;
+    const cmd = rowFor(el, s.id)?.querySelector<HTMLElement>(".card-line2 .leaf-cmd");
+    expect(cmd?.querySelector(".tool-icon")?.getAttribute("data-tool")).toBe("claude");
+    expect(cmd?.getAttribute("title")).toBe("claude");
+    // The icon said it all: no text left over.
+    expect(cmd?.querySelector(".leaf-cmd-rest")).toBeNull();
+  });
+
+  it("drops the command's arguments, keeping them in the tooltip", () => {
+    const s = session({
+      id: "aaaaaaaa-0000-0000-0000-00000000001c",
+      command: "claude --dangerously-skip-permissions",
+    });
+    const el = renderSidebar(storeWith([s])).el;
+    const cmd = rowFor(el, s.id)?.querySelector<HTMLElement>(".card-line2 .leaf-cmd");
+    expect(cmd?.querySelector(".tool-icon")?.getAttribute("data-tool")).toBe("claude");
+    expect(cmd?.querySelector(".leaf-cmd-rest")).toBeNull();
+    expect(cmd?.getAttribute("title")).toBe("claude --dangerously-skip-permissions");
+  });
+
+  it("keeps an unknown command as plain text", () => {
+    const s = session({
+      id: "aaaaaaaa-0000-0000-0000-00000000001d",
+      command: "hx src/main.rs",
+    });
+    const el = renderSidebar(storeWith([s])).el;
+    const cmd = rowFor(el, s.id)?.querySelector<HTMLElement>(".card-line2 .leaf-cmd");
+    expect(cmd?.querySelector(".tool-icon")).toBeNull();
+    expect(cmd?.querySelector(".leaf-cmd-rest")?.textContent).toBe("hx");
+    expect(cmd?.getAttribute("title")).toBe("hx src/main.rs");
+  });
+
+  it("maps each activity state to its contract slug", () => {
+    const mk = (id: string, activity: string) =>
+      session({
+        id,
+        activity: activity as Session["activity"],
+        status: "Running",
+        activity_since: ago(90_000),
+      });
+    const idle = mk("aaaaaaaa-0000-0000-0000-000000000013", "Idle");
+    const wait = mk("aaaaaaaa-0000-0000-0000-000000000014", "AwaitingInput");
+    const error = mk("aaaaaaaa-0000-0000-0000-000000000015", "Error");
+    const el = renderSidebar(storeWith([idle, wait, error])).el;
+    expect(rowFor(el, idle.id)?.querySelector(".card-line2")?.getAttribute("data-activity")).toBe(
+      "idle",
+    );
+    expect(rowFor(el, wait.id)?.querySelector(".card-line2")?.getAttribute("data-activity")).toBe(
+      "awaiting-input",
+    );
+    expect(rowFor(el, error.id)?.querySelector(".card-line2")?.getAttribute("data-activity")).toBe(
+      "error",
+    );
+  });
+
+  it("treats an unknown activity variant as idle instead of failing to render", () => {
+    const s = session({
+      id: "aaaaaaaa-0000-0000-0000-000000000016",
+      activity: "Teleported" as Session["activity"],
+      activity_since: ago(120_000),
+    });
+    const el = renderSidebar(storeWith([s])).el;
+    const line2 = rowFor(el, s.id)?.querySelector(".card-line2");
+    expect(line2?.getAttribute("data-activity")).toBe("idle");
+    expect(line2?.querySelector(".activity-duration")?.textContent).toBe("2m");
+  });
+
+  it("moves blocked work onto line 2 as diff notation", () => {
+    const s = session({
+      id: "aaaaaaaa-0000-0000-0000-000000000017",
+      blocked_work: {
+        uncommitted_files: 3,
+        unpushed_commits: 2,
+        insertions: 124,
+        deletions: 18,
+      },
+    });
+    const el = renderSidebar(storeWith([s])).el;
+    const line2 = rowFor(el, s.id)?.querySelector<HTMLElement>(".card-line2");
+    expect(line2?.textContent).toContain("+124");
+    expect(line2?.textContent).toContain("-18");
+    // Line 1 carries no badges.
+    expect(rowFor(el, s.id)?.querySelector(".leaf-badge")).toBeNull();
+  });
+
+  it("shows exited on line 2 for dead sessions", () => {
+    const s = session({
+      id: "aaaaaaaa-0000-0000-0000-000000000018",
+      status: "Dead",
+    });
+    const el = renderSidebar(storeWith([s])).el;
+    const line2 = rowFor(el, s.id)?.querySelector<HTMLElement>(".card-line2");
+    expect(line2?.textContent).toContain("exited");
+  });
+
+  // #162: a session recovered with no tmux behind it is known but not running,
+  // and never reads as something that exited.
+  it("shows dormant on line 2 for dormant sessions", () => {
+    const s = session({
+      id: "aaaaaaaa-0000-0000-0000-000000000118",
+      status: "Dormant",
+    });
+    const el = renderSidebar(storeWith([s])).el;
+    const line2 = rowFor(el, s.id)?.querySelector<HTMLElement>(".card-line2");
+    expect(line2?.textContent).toContain("dormant");
+    expect(line2?.textContent).not.toContain("exited");
+  });
+
+  // #168: a dormant card is a muted variant with a resume action in place of
+  // "spawn similar", since there is nothing running to clone from live state.
+  it("renders a dormant card muted, with a resume action instead of spawn-similar", async () => {
+    const calls: string[] = [];
+    window.fetch = ((url: string, init?: RequestInit) => {
+      calls.push(`${init?.method ?? "GET"} ${url}`);
+      return Promise.resolve(
+        new Response(JSON.stringify({ id: "aaaaaaaa-0000-0000-0000-000000000120", status: "Running" }), {
+          status: 200,
+        }),
+      );
+    }) as typeof fetch;
+    const s = session({ id: "aaaaaaaa-0000-0000-0000-000000000120", status: "Dormant" });
+    const el = renderSidebar(storeWith([s])).el;
+    const row = rowFor(el, s.id) as HTMLElement;
+    expect(row.classList.contains("is-dormant")).toBe(true);
+    expect(row.querySelector(".leaf-clone")).toBeNull();
+    const resumeBtn = row.querySelector<HTMLButtonElement>(".leaf-resume");
+    expect(resumeBtn).toBeTruthy();
+    resumeBtn?.click();
+    await flush();
+    expect(calls).toContain(`POST /api/sessions/${s.id}/resume`);
+  });
+
+  // #168: a two-way running/dead test made a dormant card lie to screen
+  // readers — the visible flag says dormant, the aria-label said "exited".
+  it("marks a dormant row's status and aria-label distinctly from dead", () => {
+    const s = session({
+      id: "aaaaaaaa-0000-0000-0000-000000000119",
+      status: "Dormant",
+    });
+    const el = renderSidebar(storeWith([s])).el;
+    const row = rowFor(el, s.id) as HTMLElement;
+    expect(row.dataset.status).toBe("dormant");
+    expect(row.getAttribute("aria-label")).toContain("dormant");
+    expect(row.getAttribute("aria-label")).not.toContain("exited");
+  });
+
+  it("carries the state word only in tooltips and aria labels, never as text", () => {
+    const s = session({
+      id: "aaaaaaaa-0000-0000-0000-000000000019",
+      command: "claude",
+      metadata: { name: "worker" },
+      activity: "AwaitingInput",
+      activity_since: ago(90_000),
+    });
+    const el = renderSidebar(storeWith([s])).el;
+    const row = rowFor(el, s.id) as HTMLElement;
+    const rail = row.querySelector<HTMLElement>(".activity-rail");
+    expect(rail?.getAttribute("title")).toContain("Awaiting input");
+    expect(rail?.getAttribute("aria-label")).toContain("Awaiting input");
+    expect(row.textContent).not.toMatch(/awaiting.?input/i);
+  });
+
+  it("keeps the attach navigation and depth indentation", () => {
+    const s = session({ id: "aaaaaaaa-0000-0000-0000-00000000001a" });
+    const el = renderSidebar(storeWith([s])).el;
+    const row = rowFor(el, s.id) as HTMLAnchorElement;
+    expect(row.getAttribute("href")).toBe("#/attach/aaaaaaaa-0000-0000-0000-00000000001a");
+    expect(row.style.paddingLeft).toMatch(/^\d+(\.\d+)?px$/);
+  });
+});

web/src/catalog.ts

@@ -0,0 +1,913 @@
+import { escapeHtml } from "./html.js";
+import { ApiRequestError, getDaemonInfo, killSession, renameSession, resumeSession } from "./api.js";
+import { openForceKillDialog, openKillConfirmDialog } from "./killDialog.js";
+import { openContextMenu } from "./contextMenu.js";
+import { toggleHelp } from "./help.js";
+import { CommandSet, defineCommands } from "./commands.js";
+import { CatalogStore } from "./events.js";
+import type { InTheWay, Session } from "./types.js";
+import {
+  abbreviateCwd,
+  abbreviateFolderName,
+  blockerStats,
+  customSessionName,
+  formatInTheWay,
+  MAX_SESSION_NAME_LEN,
+  normalizeSessionName,
+  sessionBlockers,
+  isProvisionalName,
+  sessionName,
+  sessionTreePath,
+} from "./types.js";
+import { splitCommand, toolIconSvg } from "./toolIcon.js";
+import {
+  activityColorSlug,
+  activityDurationLabel,
+  activityHeldMs,
+  META_LINE_MIN_HOLD_MS,
+} from "./activity.js";
+import type { TreeNode } from "./tree.js";
+import { buildTree } from "./tree.js";
+import { createPaletteSelect, createThemeToggle } from "./theme.js";
+import type { DaemonLink } from "./daemonLink.js";
+import { createStatusIndicator } from "./statusIndicator.js";
+
+/** Ask the shell to open the spawn modal. Handled in main.ts, where the
+ *  multi-view controller lives; dispatched from every Spawn affordance. */
+export const OPEN_SPAWN_EVENT = "catalog-open-spawn";
+export function requestOpenSpawn(): void {
+  document.dispatchEvent(new CustomEvent(OPEN_SPAWN_EVENT));
+}
+
+/** Ask the shell to open the command bar with an empty query. Dispatched by
+ *  the sidebar's search field, which is the touch entry point to the bar
+ *  (#157, docs/COMMAND-BAR.md "Touch entry"): there is no `ctrl-k` on a phone.
+ *  Handled in main.ts, which owns the session snapshot the bar needs. */
+export const OPEN_COMMAND_BAR_EVENT = "catalog-open-command-bar";
+export function requestOpenCommandBar(): void {
+  document.dispatchEvent(new CustomEvent(OPEN_COMMAND_BAR_EVENT));
+}
+
+/** Ask the shell to hand the keyboard back to the focused pane's terminal —
+ *  what Tab in the sidebar list does. Handled in main.ts, which owns the
+ *  connection pool. */
+export const FOCUS_PANE_EVENT = "catalog-focus-pane";
+
+/** Ask the shell to hand the keyboard back to the session list — what Escape
+ *  does when the pane's terminal is focused. Handled in main.ts. */
+export const FOCUS_SIDEBAR_EVENT = "catalog-focus-sidebar";
+
+/** Ask the shell to open the spawn modal seeded from an existing session
+ *  ("Spawn similar"). Detail is the session being cloned. */
+export const SPAWN_SIMILAR_EVENT = "catalog-spawn-similar";
+
+/** Ask the sidebar to kill a session — the command bar's action page picking
+ *  `kill` (#151). Detail is the session. Handled here, so the kill goes
+ *  through the same confirm-and-blockers flow the card's ✕ does
+ *  (`docs/WORKTREES.md`); the bar never reimplements it. */
+export const KILL_SESSION_EVENT = "catalog-kill-session";
+
+/** Ask the sidebar to rename a session — the command bar's action page picking
+ *  `rename` (#151). Detail is the session. The prompt is the card's own inline
+ *  field, pre-filled with the session's name (`docs/SIDEBAR.md`). */
+export const RENAME_SESSION_EVENT = "catalog-rename-session";
+
+/** A session row was clicked (issue #133). The row's `href` drives normal
+ *  hash navigation, but a split/drag can move focus without ever touching
+ *  `location.hash` — so a click back onto a session whose hash still
+ *  matches fires no `hashchange` and the app never hears about it. This
+ *  event is the click-driven path that doesn't depend on the hash actually
+ *  changing. */
+export const SESSION_SELECT_EVENT = "catalog-session-select";
+
+/** The rows a keyboard walk stops on, in visual (document) order. Expanded
+ *  folder headers are skipped: a directory is not something to focus, and the
+ *  cards under it are one row away anyway. A *collapsed* folder still counts —
+ *  its header is the only row it has, so skipping it would leave the folder
+ *  unreachable. Same rule as the TUI sidebar. */
+const NAV_SELECTOR = '.tree-leaf, .tree-folder-header[aria-expanded="false"]';
+
+const collapsed = new Set<string>();
+
+/** Session whose card is currently being renamed inline (#125). The tree
+ * re-renders on every catalog delta, and an activity update arriving mid-edit
+ * would otherwise replace the field the user is typing into. */
+let renamingId: string | null = null;
+
+// docs/SIDEBAR.md: the state word is never rendered — the rail's colour
+// carries it. It survives only in tooltips/aria labels so meaning is not
+// colour-only.
+const STATE_WORDS: Record<string, string> = {
+  active: "Active",
+  idle: "Idle",
+  "awaiting-input": "Awaiting input",
+  error: "Error",
+};
+
+// #168: dormancy is not an exit (docs/SIDEBAR.md), so `dataset.status` and
+// the aria-label read the session's own three-way `status` rather than a
+// two-way running/dead test that folded `Dormant` into "dead"/"exited".
+function statusSlug(status: Session["status"]): string {
+  if (status === "Running") return "running";
+  if (status === "Dormant") return "dormant";
+  return "dead";
+}
+
+function statusWord(status: Session["status"]): string {
+  if (status === "Running") return "running";
+  if (status === "Dormant") return "dormant";
+  return "exited";
+}
+
+/** docs/SIDEBAR.md: the activity rail is pinned to the row's own left edge,
+ * full height. The row's own padding (`renderNode`) shifts outward with
+ * nesting depth, carrying the rail with it. */
+function activityRailMarkup(slug: string, stateWord: string): string {
+  return `<span class="activity-rail" data-activity="${slug}" role="img" title="${escapeHtml(stateWord)}" aria-label="${escapeHtml(stateWord)}"></span>`;
+}
+
+function metaLine(s: Session, now: number): string {
+  const dead = s.status === "Dead";
+  // #162: known from its sidecar with nothing running behind it — a distinct
+  // fragment, since it never exited.
+  const dormant = s.status === "Dormant";
+  const blockers = sessionBlockers(s);
+  const slug = activityColorSlug(s.activity ?? "Idle");
+  const held = activityHeldMs(s.activity_since, now);
+  const duration =
+    held !== null && held >= META_LINE_MIN_HOLD_MS ? activityDurationLabel(held) : null;
+
+  const fragments = [
+    duration ? `<span class="activity-duration">${duration}</span>` : "",
+    s.activity_detail
+      ? `<span class="activity-detail">${escapeHtml(s.activity_detail)}</span>`
+      : "",
+    commandFragment(s.command),
+    blockers ? blockedFragment(blockers) : "",
+    dead ? `<span class="card-flag">exited</span>` : "",
+    dormant ? `<span class="card-flag">dormant</span>` : "",
+  ];
+  return `<span class="card-line2" data-activity="${slug}">${fragments.join("")}</span>`;
+}
+
+/** docs/SIDEBAR.md: blocked work renders as diff notation — `+124 -18 ?3 ↑2`
+ * — with the spelled-out breakdown kept in the tooltip. */
+function blockedFragment(blockers: InTheWay): string {
+  const stats = blockerStats(blockers)
+    .map((st) => `<span class="blocked-stat" data-stat="${st.kind}">${escapeHtml(st.text)}</span>`)
+    .join("");
+  const title = `Kill will be refused unless forced — ${formatInTheWay(blockers)}`;
+  return `<span class="card-flag leaf-blocked" title="${escapeHtml(title)}">${stats}</span>`;
+}
+
+/** docs/SIDEBAR.md: the card names the program only — arguments never reach
+ * the card. The program becomes its tool icon when we have a mark for it, and
+ * stays as its bare name when we do not. The full command line, arguments and
+ * all, stays in the tooltip either way. */
+function commandFragment(command: string): string {
+  const { tool, program } = splitCommand(command);
+  const icon = tool ? toolIconSvg(tool) : null;
+  const text = icon ? "" : program;
+  return `<span class="card-flag leaf-cmd" title="${escapeHtml(command)}">${icon ?? ""}${text ? `<span class="leaf-cmd-rest">${escapeHtml(text)}</span>` : ""}</span>`;
+}
+
+function renderNode(node: TreeNode, depth: number): HTMLElement {
+  if (node.kind === "folder") {
+    const wrap = document.createElement("div");
+    wrap.className = "tree-folder";
+
+    if (node.name) {
+      const header = document.createElement("button");
+      header.type = "button";
+      header.className = "tree-folder-header";
+      header.style.paddingLeft = `${depth * 16}px`;
+      const isCollapsed = collapsed.has(node.path);
+      header.setAttribute("aria-expanded", String(!isCollapsed));
+      header.dataset.navKey = `folder:${node.path}`;
+      // Single down-chevron; CSS rotates it -90° (→ right) when collapsed, so the
+      // glyph and the rotation never fight each other.
+      // A deep path (`~/git.naps.pt/naps62/maestro`) collapses its leading
+      // segments to initials (`~/g/n/maestro`) so the dir name stays readable in
+      // a narrow sidebar; the full path lives in the tooltip.
+      header.innerHTML = `<span class="chevron">▾</span><span class="folder-name" title="${escapeHtml(node.name)}">${abbreviateFolderName(node.name)}</span>`;
+      header.addEventListener("click", () => {
+        if (collapsed.has(node.path)) collapsed.delete(node.path);
+        else collapsed.add(node.path);
+        // re-render handled by caller observing the store; trigger a refresh:
+        document.dispatchEvent(new CustomEvent("catalog-rerender"));
+      });
+      wrap.appendChild(header);
+      if (isCollapsed) return wrap;
+    }
+
+    for (const child of node.children) {
+      wrap.appendChild(renderNode(child, node.name ? depth + 1 : depth));
+    }
+    return wrap;
+  }
+
+  // The row outlives the snapshot it was built from: a refresh that changes
+  // nothing structural patches it in place rather than replacing it, so the
+  // handlers below have to read the current session, not the one captured here.
+  let cur = node.session;
+  const s = node.session;
+  const now = Date.now();
+  const row = document.createElement("a");
+  row.className = "tree-leaf session-card";
+  row.href = `#/attach/${encodeURIComponent(s.id)}`;
+  row.style.paddingLeft = `${depth * 16 + 8}px`;
+  row.dataset.sessionId = s.id;
+  row.dataset.navKey = `session:${s.id}`;
+  row.dataset.status = statusSlug(s.status);
+  // docs/SIDEBAR.md: a dormant card is a muted variant — nothing running
+  // behind it, so it earns no activity colour or spawn-similar affordance.
+  const dormant = s.status === "Dormant";
+  row.classList.toggle("is-dormant", dormant);
+  const name = sessionName(s);
+  const slug = activityColorSlug(s.activity ?? "Idle");
+  const stateWord = STATE_WORDS[slug] ?? STATE_WORDS.idle;
+  row.setAttribute("aria-label", `${name}, ${statusWord(s.status)}, ${stateWord}`);
+  const cloneOrResumeAction = dormant
+    ? `<button class="leaf-act leaf-resume" type="button" title="Resume session" aria-label="Resume ${escapeHtml(name)}">↻</button>`
+    : `<button class="leaf-act leaf-clone" type="button" title="Spawn similar" aria-label="Spawn similar to ${escapeHtml(name)}">⧉</button>`;
+  // docs/SIDEBAR.md: line 1 reserves action width, and line 2 is unconditional.
+  row.innerHTML = `
+    ${activityRailMarkup(slug, stateWord)}
+    <span class="card-line1">
+      <span class="leaf-name${isProvisionalName(s) ? " is-provisional" : ""}">${escapeHtml(name)}</span>
+      <span class="leaf-actions">
+        ${cloneOrResumeAction}
+        <button class="leaf-act leaf-kill" type="button" title="Kill session" aria-label="Kill ${escapeHtml(name)}">✕</button>
+      </span>
+    </span>
+    ${metaLine(s, now)}
+  `;
+  const similarBtn = row.querySelector<HTMLButtonElement>(".leaf-clone");
+  similarBtn?.addEventListener("click", (ev) => {
+    ev.preventDefault();
+    ev.stopPropagation();
+    document.dispatchEvent(new CustomEvent(SPAWN_SIMILAR_EVENT, { detail: cur }));
+  });
+  const resumeBtn = row.querySelector<HTMLButtonElement>(".leaf-resume");
+  resumeBtn?.addEventListener("click", (ev) => {
+    ev.preventDefault();
+    ev.stopPropagation();
+    resumeBtn.disabled = true;
+    void resumeSession(cur.id).catch((e: Error) => {
+      resumeBtn.disabled = false;
+      alert(`Failed to resume: ${e.message}`);
+    });
+  });
+  const killBtn = row.querySelector(".leaf-kill") as HTMLButtonElement;
+  killBtn.addEventListener("click", (ev) => {
+    ev.preventDefault();
+    ev.stopPropagation();
+    requestKill(cur, sessionName(cur));
+  });
+  row.addEventListener("click", () => {
+    document.dispatchEvent(new CustomEvent(SESSION_SELECT_EVENT, { detail: cur.id }));
+  });
+  row.addEventListener("contextmenu", (ev) => {
+    ev.preventDefault();
+    ev.stopPropagation();
+    openContextMenu(ev.clientX, ev.clientY, [
+      { label: "Rename…", onSelect: () => beginRename(row, cur) },
+      cur.status === "Dormant"
+        ? {
+            label: "Resume",
+            onSelect: () =>
+              void resumeSession(cur.id).catch((e: Error) =>
+                alert(`Failed to resume: ${e.message}`),
+              ),
+          }
+        : {
+            label: "Spawn similar",
+            onSelect: () =>
+              document.dispatchEvent(new CustomEvent(SPAWN_SIMILAR_EVENT, { detail: cur })),
+          },
+      {
+        label: "Kill session",
+        danger: true,
+        onSelect: () => requestKill(cur, sessionName(cur)),
+      },
+    ]);
+  });
+  leafPatches.set(row, (next) => {
+    cur = next;
+    const nextSlug = activityColorSlug(next.activity ?? "Idle");
+    const nextWord = STATE_WORDS[nextSlug] ?? STATE_WORDS.idle;
+    row.dataset.status = statusSlug(next.status);
+    row.setAttribute("aria-label", `${sessionName(next)}, ${statusWord(next.status)}, ${nextWord}`);
+    const rail = row.querySelector(".activity-rail");
+    if (rail) rail.outerHTML = activityRailMarkup(nextSlug, nextWord);
+    const meta = row.querySelector(".card-line2");
+    if (meta) meta.outerHTML = metaLine(next, Date.now());
+  });
+  return row;
+}
+
+/** Refresh a standing card from a newer snapshot of its session, keeping the
+ *  element (and so the pointer's `:hover`) exactly where it is. Registered by
+ *  `renderNode`; only the bits `treeSignature` leaves out are rewritten. */
+const leafPatches = new WeakMap<HTMLElement, (s: Session) => void>();
+
+/**
+ * Everything about the tree that a patch cannot fix up.
+ *
+ * The daemon re-sends a session on every activity, foreground or cwd shift —
+ * a couple of times a minute per live session — and rebuilding the sidebar for
+ * each one drops `:hover` from the row under the pointer. Refreshes whose
+ * signature is unchanged are patched into the standing rows instead; anything
+ * that moves, renames, appears or dies changes the signature and rebuilds.
+ */
+function treeSignature(node: TreeNode): string {
+  if (node.kind === "folder") {
+    const head = `F:${node.name}:${node.path}:${collapsed.has(node.path)}`;
+    if (node.name && collapsed.has(node.path)) return head;
+    return `${head}(${node.children.map(treeSignature).join(",")})`;
+  }
+  const s = node.session;
+  return `L:${s.id}:${sessionName(s)}:${s.status}:${isProvisionalName(s)}`;
+}
+
+/**
+ * Kill behind a confirmation (#160): a kill is destructive and unattended
+ * agents live in these sessions, so the web asks first, the way the TUI always
+ * has. The daemon decides the rest — it refuses a kill over a worktree holding
+ * unsaved work, and that refusal needs a prompt the confirmation cannot give,
+ * a forced kill. Anything else surfaces in the dialog that asked.
+ */
+function requestKill(s: Session, name: string): void {
+  openKillConfirmDialog({
+    name,
+    blockers: sessionBlockers(s),
+    onKill: async () => {
+      try {
+        await killSession(s.id);
+      } catch (e) {
+        if (e instanceof ApiRequestError && e.code === "kill_guarded") {
+          openForceKillDialog({
+            name,
+            blockers: e.unsavedWork ?? sessionBlockers(s),
+            reason: e.detail,
+            onForce: () => killSession(s.id, true),
+          });
+          return;
+        }
+        throw e;
+      }
+    },
+  });
+}
+
+/**
+ * Swap the card's name for a text field (#125). Enter commits, Escape and
+ * blur cancel. An emptied field clears the name, so the card falls back to
+ * the command — the same rule the spawn form's blank name field follows.
+ */
+function beginRename(row: HTMLElement, s: Session): void {
+  const nameEl = row.querySelector<HTMLElement>(".leaf-name");
+  if (!nameEl) return;
+  const input = document.createElement("input");
+  input.type = "text";
+  input.className = "leaf-name leaf-rename";
+  input.value = customSessionName(s) ?? "";
+  input.maxLength = MAX_SESSION_NAME_LEN;
+  input.setAttribute("aria-label", `Rename ${sessionName(s)}`);
+  // The card is an <a>, and the tree starts a drag on pointerdown: without
+  // these, clicking into the field navigates away or begins dragging the row.
+  for (const type of ["click", "pointerdown", "dblclick"]) {
+    input.addEventListener(type, (ev) => {
+      ev.preventDefault();
+      ev.stopPropagation();
+      input.focus();
+    });
+  }
+
+  renamingId = s.id;
+  let settled = false;
+  const finish = () => {
+    if (settled) return false;
+    settled = true;
+    renamingId = null;
+    document.dispatchEvent(new CustomEvent("catalog-rerender"));
+    return true;
+  };
+
+  input.addEventListener("keydown", (ev) => {
+    if (ev.key === "Enter") {
+      ev.preventDefault();
+      // Normalised here so what is sent is what the daemon will store.
+      const name = normalizeSessionName(input.value);
+      if (!finish()) return;
+      void renameSession(s.id, name).catch((e: Error) => {
+        alert(`Failed to rename: ${e.message}`);
+      });
+    } else if (ev.key === "Escape") {
+      ev.preventDefault();
+      finish();
+    }
+  });
+  input.addEventListener("blur", () => finish());
+
+  nameEl.replaceWith(input);
+  input.focus();
+  input.select();
+}
+
+// The tree has one empty state: no sessions at all. The old "No matches" one
+// belonged to the inline substring filter, which the command bar replaced
+// (#157) — the bar's own no-results state took over with it.
+function renderEmpty(onSpawn: () => void): HTMLElement {
+  const el = document.createElement("div");
+  el.className = "empty";
+  el.innerHTML = `
+    <div class="empty-glyph" aria-hidden="true">+</div>
+    <div class="empty-title">No sessions yet</div>
+    <p class="empty-hint">Start your first session — it'll show up here.</p>
+    <div class="empty-actions"></div>`;
+  const spawn = document.createElement("button");
+  spawn.type = "button";
+  spawn.className = "btn btn-primary";
+  spawn.textContent = "+ Spawn session";
+  spawn.addEventListener("click", onSpawn);
+  (el.querySelector(".empty-actions") as HTMLElement).appendChild(spawn);
+  return el;
+}
+
+/** Two-tier sidebar highlight state (issue #33): which sessions are open in some
+ *  pane (quiet), and which one is focused (loud). */
+export interface SidebarHighlights {
+  open: Set<string>;
+  focused: string | null;
+}
+
+/** Live handle to the persistent sidebar (built once, survives navigation). */
+export interface SidebarHandle {
+  /** The `<aside>` element to mount into the shell. */
+  el: HTMLElement;
+  /** Highlight the row for `id` (or clear it with `null`) as the focused session.
+   *  Back-compat shim over {@link setHighlights}. */
+  setActive(id: string | null): void;
+  /** Apply the full open/focused highlight state. */
+  setHighlights(h: SidebarHighlights): void;
+  /** Mark the row the content pane is previewing (docs/PREVIEW.md), or clear it
+   *  with `null`. A preview is a view, not state, so this only paints. */
+  setPreview(sessionId: string | null): void;
+  /** Hand the keyboard to the session list, highlighting a row to walk from. */
+  focusList(): void;
+  /** Whether the session list currently holds DOM focus. */
+  hasListFocus(): boolean;
+  /** Tear down the store subscription + listeners. */
+  dispose(): void;
+}
+
+/**
+ * Build the persistent session sidebar: brand, search, spawn, theme toggle, a
+ * live session status line, and the folder-grouped session tree. Unlike
+ * the old full-screen catalog this is mounted once by the shell and stays put
+ * while the content pane swaps between sessions — so the store subscription and
+ * scroll position survive navigation. The active session is highlighted.
+ */
+export interface SidebarOptions {
+  /** Pointerdown on a session row — the multi-view controller decides drag vs
+   *  tap (issue #32). Tap falls through to the row's normal click (open). */
+  onLeafDrag?: (sessionId: string, e: PointerEvent) => void;
+  /** Daemon link behind the footer's status dot. Omitted in tests and in the
+   *  design kit, which render the sidebar without a daemon. */
+  link?: DaemonLink;
+  /** The highlight moved onto a session, or off every session (`null`): the
+   *  shell shows it in the content pane without opening it (docs/PREVIEW.md).
+   *  `source` is there so a mouse sweep can be debounced differently from a
+   *  keyboard step. */
+  onPreview?: (sessionId: string | null) => void;
+}
+
+export function renderSidebar(store: CatalogStore, opts: SidebarOptions = {}): SidebarHandle {
+  const el = document.createElement("aside");
+  el.className = "sidebar";
+
+  // The daemon's home dir abbreviates cwds to `~/…`. Fetched once; the tree
+  // renders with absolute paths until it lands.
+  let homeDir: string | undefined;
+
+  // The field never holds a query: it is the touch entry point to the command
+  // bar (#157), so it is `readonly` — a tap opens the bar instead of raising an
+  // on-screen keyboard over a field nothing is typed into.
+  const searchHeader = document.createElement("header");
+  searchHeader.className = "sidebar-search";
+  searchHeader.innerHTML = `
+    <input
+      type="search"
+      class="search"
+      readonly
+      placeholder="Search sessions…"
+      aria-label="Search sessions"
+      autocomplete="off"
+      autocorrect="off"
+      autocapitalize="off"
+      spellcheck="false"
+    />
+  `;
+  el.appendChild(searchHeader);
+
+  const treeHost = document.createElement("div");
+  treeHost.className = "tree";
+  el.appendChild(treeHost);
+
+  // App-level actions (help, theme, spawn) live pinned to the sidebar's foot
+  // rather than the sidebar's own scrolling content, so they stay reachable
+  // regardless of tree scroll position.
+  const footer = document.createElement("div");
+  footer.className = "sidebar-footer";
+  const helpBtn = document.createElement("button");
+  helpBtn.type = "button";
+  helpBtn.className = "btn btn-ghost btn-icon help-btn";
+  helpBtn.textContent = "?";
+  helpBtn.title = "Keyboard shortcuts (?)";
+  helpBtn.setAttribute("aria-label", "Keyboard shortcuts");
+  helpBtn.addEventListener("click", () => toggleHelp());
+  footer.appendChild(helpBtn);
+  footer.appendChild(createThemeToggle());
+  footer.appendChild(createPaletteSelect());
+  // DEV-only shortcut to the standalone design kit (?kit). Lets you reach it by
+  // clicking inside a proxied preview (e.g. crit live) that has no address bar.
+  if (import.meta.env.DEV) {
+    const kit = document.createElement("a");
+    kit.className = "btn btn-ghost";
+    kit.href = "?kit";
+    kit.textContent = "kit";
+    kit.title = "Open the design kit (DEV)";
+    footer.appendChild(kit);
+  }
+  // Daemon status sits beside the spawn button: colour for the link state,
+  // hover for the release the daemon is running.
+  const status = opts.link ? createStatusIndicator(opts.link) : null;
+  if (status) footer.appendChild(status.el);
+  const spawnBtn = document.createElement("button");
+  spawnBtn.type = "button";
+  spawnBtn.className = "btn btn-primary spawn-btn";
+  spawnBtn.textContent = "+ Spawn";
+  // The keyboard pair sits right here in the tooltip (#67).
+  spawnBtn.title = "Spawn form: n — fast-forward spawn: N";
+  spawnBtn.addEventListener("click", () => requestOpenSpawn());
+  footer.appendChild(spawnBtn);
+  el.appendChild(footer);
+
+  // Drag a session row into the canvas (issue #32). Delegated so it survives
+  // tree re-renders; the controller handles drag-vs-tap (tap still navigates).
+  treeHost.addEventListener("pointerdown", (e) => {
+    if (e.button !== 0 || !opts.onLeafDrag) return;
+    const leaf = (e.target as HTMLElement).closest<HTMLElement>(".tree-leaf");
+    const id = leaf?.dataset.sessionId;
+    if (id) opts.onLeafDrag(id, e);
+  });
+  // The rows are <a> elements, so the browser's native link drag-and-drop would
+  // otherwise hijack pointermove and our live drop-zone preview wouldn't show
+  // until release. Suppress it so the pointer-based drag runs from the start.
+  treeHost.addEventListener("dragstart", (e) => {
+    if ((e.target as HTMLElement).closest(".tree-leaf")) e.preventDefault();
+  });
+
+  // Drag-to-resize handle on the sidebar's right edge. Persists the chosen
+  // width as a :root CSS var the shell grid reads; clamped to a sane range.
+  const SIDEBAR_W_KEY = "maestro-sidebar-w";
+  const storedW = localStorage.getItem(SIDEBAR_W_KEY);
+  if (storedW) document.documentElement.style.setProperty("--sidebar-w", storedW);
+  const handle = document.createElement("div");
+  handle.className = "sidebar-resize";
+  handle.setAttribute("aria-hidden", "true");
+  el.appendChild(handle);
+  let dragStartX = 0;
+  let dragStartW = 0;
+  let dragging = false;
+  handle.addEventListener("pointerdown", (e) => {
+    dragging = true;
+    dragStartX = e.clientX;
+    dragStartW = el.getBoundingClientRect().width;
+    handle.setPointerCapture(e.pointerId);
+    document.body.style.userSelect = "none";
+    e.preventDefault();
+  });
+  handle.addEventListener("pointermove", (e) => {
+    if (!dragging) return;
+    const w = Math.max(200, Math.min(560, dragStartW + (e.clientX - dragStartX)));
+    document.documentElement.style.setProperty("--sidebar-w", `${w}px`);
+  });
+  const endDrag = (e: PointerEvent) => {
+    if (!dragging) return;
+    dragging = false;
+    try {
+      handle.releasePointerCapture(e.pointerId);
+    } catch {
+      // pointer may already be released
+    }
+    document.body.style.userSelect = "";
+    const cur = document.documentElement.style.getPropertyValue("--sidebar-w");
+    if (cur) localStorage.setItem(SIDEBAR_W_KEY, cur);
+  };
+  handle.addEventListener("pointerup", endDrag);
+  handle.addEventListener("pointercancel", endDrag);
+
+  // Touch entry (#157): the field is a button that looks like a field. It
+  // never holds a query — focusing or tapping it hands the keyboard straight
+  // to the bar's own input, which is also why it blurs first: leaving the
+  // focus here would make the bar impossible to close without reopening it.
+  const search = searchHeader.querySelector(".search") as HTMLInputElement;
+  const openBar = () => {
+    search.value = "";
+    search.blur();
+    requestOpenCommandBar();
+  };
+  search.addEventListener("focus", openBar);
+  // A tap can land without a focus event (iOS Safari on a blurred field), so
+  // the pointer path opens the bar too; the blur above keeps the two from
+  // stacking two overlays.
+  search.addEventListener("pointerdown", (e) => {
+    e.preventDefault();
+    openBar();
+  });
+
+  let highlights: SidebarHighlights = { open: new Set(), focused: null };
+  // The previewed row is painted alongside the open/focused tiers so a
+  // re-render can't drop it, but it is never part of `highlights`: a preview
+  // is a view, and nothing about it is durable (docs/PREVIEW.md).
+  let previewing: string | null = null;
+  const applyHighlights = () => {
+    for (const n of treeHost.querySelectorAll<HTMLElement>(".tree-leaf")) {
+      const id = n.dataset.sessionId;
+      if (!id) continue;
+      const focused = highlights.focused === id;
+      const open = highlights.open.has(id);
+      n.classList.toggle("is-active", focused);
+      n.classList.toggle("is-open", open && !focused);
+      n.classList.toggle("is-previewing", previewing === id);
+    }
+  };
+
+  // ---- keyboard navigation ----
+  // The walk reads the rendered DOM rather than a parallel model, so it can
+  // never disagree with what is on screen. Rows carry a `data-nav-key`
+  // (`session:<id>` / `folder:<path>`) that survives a re-render.
+  let navKey: string | null = null;
+
+  const navRows = (): HTMLElement[] => [
+    ...treeHost.querySelectorAll<HTMLElement>(NAV_SELECTOR),
+  ];
+
+  const rowFor = (key: string | null): HTMLElement | undefined =>
+    key === null ? undefined : navRows().find((r) => r.dataset.navKey === key);
+
+  const applyNav = () => {
+    const rows = navRows();
+    // A row that went away (session killed, folder collapsed) drops the
+    // highlight rather than leaving it pointing at nothing.
+    if (navKey !== null && !rows.some((r) => r.dataset.navKey === navKey)) navKey = null;
+    for (const r of rows) r.classList.toggle("is-highlighted", r.dataset.navKey === navKey);
+  };
+
+  const sessionOf = (key: string | null): string | null =>
+    key?.startsWith("session:") ? key.slice("session:".length) : null;
+
+  const moveNav = (delta: number) => {
+    const rows = navRows();
+    if (rows.length === 0) return;
+    const cur = rows.findIndex((r) => r.dataset.navKey === navKey);
+    // Nothing highlighted: start one off the end we are walking from, so the
+    // first step lands on the first (or last) row.
+    const from = cur === -1 ? (delta > 0 ? -1 : 0) : cur;
+    const next = rows[(((from + delta) % rows.length) + rows.length) % rows.length];
+    navKey = next.dataset.navKey ?? null;
+    applyNav();
+    next.scrollIntoView({ block: "nearest" });
+    opts.onPreview?.(sessionOf(navKey));
+  };
+
+  /** Enter: open the highlighted session, or expand the highlighted folder. */
+  const activateNav = () => {
+    const row = rowFor(navKey);
+    if (!row) return;
+    if (row.classList.contains("tree-leaf")) {
+      row.click();
+      return;
+    }
+    // Expanding replaces the folder's header in the walk with the rows it was
+    // hiding, so land on the first of them instead of losing the highlight.
+    const key = navKey;
+    row.click();
+    const header = [...treeHost.querySelectorAll<HTMLElement>(".tree-folder-header")].find(
+      (h) => h.dataset.navKey === key,
+    );
+    const revealed = header?.parentElement
+      ? [...header.parentElement.querySelectorAll<HTMLElement>(NAV_SELECTOR)][0]
+      : undefined;
+    navKey = revealed?.dataset.navKey ?? null;
+    applyNav();
+  };
+
+  // Hover previews the row under the pointer (docs/PREVIEW.md). Touch is left
+  // out: there is no hover there, and a tap already opens the session.
+  let hovered: string | null = null;
+  const setHovered = (id: string | null) => {
+    if (hovered === id) return;
+    hovered = id;
+    opts.onPreview?.(id);
+  };
+  treeHost.addEventListener("pointerover", (e) => {
+    if (e.pointerType === "touch") return;
+    const row = (e.target as HTMLElement | null)?.closest<HTMLElement>(".tree-leaf");
+    setHovered(row?.dataset.sessionId ?? null);
+  });
+  treeHost.addEventListener("pointerleave", (e) => {
+    if (e.pointerType === "touch") return;
+    setHovered(null);
+  });
+
+  // Focusable as a unit: the walk moves a highlight, not DOM focus, so the
+  // keyboard stays here while j/k runs.
+  treeHost.tabIndex = -1;
+  // The keyboard walk's preview belongs to the list having the keyboard: once
+  // it doesn't, the content pane goes back to what the operator actually opened.
+  treeHost.addEventListener("blur", () => opts.onPreview?.(null));
+
+  /** The session behind the highlighted row, if the highlight is on a card. */
+  const highlightedSession = (): { row: HTMLElement; session: Session } | undefined => {
+    const row = rowFor(navKey);
+    const id = row?.dataset.sessionId;
+    if (!row || !id) return undefined;
+    const session = store.snapshot().sessions.get(id);
+    return session ? { row, session } : undefined;
+  };
+
+  /** `c`: collapse or expand the highlighted folder, the TUI's
+   *  `ToggleSidebarGroup`. Clicking the header is what toggles it; on a card
+   *  the key does nothing rather than toggling some other folder. */
+  const toggleHighlightedFolder = () => {
+    const row = rowFor(navKey);
+    if (!row || !row.classList.contains("tree-folder-header")) return;
+    row.click();
+    applyNav();
+  };
+
+  // The session list's half of the command registry (#148). One set per
+  // sidebar, so a second sidebar (tests, hot reload) drives its own rows; the
+  // labels and chords still come from the one registry.
+  const listKeys = new CommandSet(
+    defineCommands({
+      "list.next": () => moveNav(1),
+      "list.prev": () => moveNav(-1),
+      "list.activate": () => activateNav(),
+      "list.toggleFolder": () => toggleHighlightedFolder(),
+      "list.rename": () => {
+        const hit = highlightedSession();
+        if (hit) beginRename(hit.row, hit.session);
+      },
+      "list.kill": () => {
+        const hit = highlightedSession();
+        if (hit) requestKill(hit.session, sessionName(hit.session));
+      },
+      "list.focusPane": () => document.dispatchEvent(new CustomEvent(FOCUS_PANE_EVENT)),
+    }),
+  );
+
+  // The inline rename field lives inside a row and owns its own keys; the set's
+  // plain-key rule keeps this walk out of it.
+  treeHost.addEventListener("keydown", (e) => listKeys.handle(e));
+
+  /** Signature of what is currently on screen — see `treeSignature`. */
+  let renderedSignature: string | null = null;
+
+  const refresh = () => {
+    // Rebuilding the tree now would blow away the field being typed into.
+    if (renamingId !== null) return;
+    const state = store.snapshot();
+    const sessions = [...state.sessions.values()];
+    const tree = buildTree(sessions, homeDir);
+    const signature = sessions.length === 0 ? "EMPTY" : treeSignature(tree);
+    if (signature === renderedSignature) {
+      for (const row of treeHost.querySelectorAll<HTMLElement>(".tree-leaf")) {
+        const s = row.dataset.sessionId ? state.sessions.get(row.dataset.sessionId) : undefined;
+        if (s) leafPatches.get(row)?.(s);
+      }
+      return;
+    }
+    renderedSignature = signature;
+    treeHost.replaceChildren();
+    if (sessions.length === 0) {
+      treeHost.appendChild(renderEmpty(() => requestOpenSpawn()));
+      return;
+    }
+    if (tree.kind === "folder") {
+      for (const child of tree.children) treeHost.appendChild(renderNode(child, 0));
+    }
+    applyHighlights();
+    applyNav();
+  };
+
+  void getDaemonInfo()
+    .then((info) => {
+      homeDir = info.home_dir;
+      refresh();
+    })
+    .catch(() => {
+      /* absolute paths are a fine fallback */
+    });
+
+  // Dispatched when something outside the store changed what the tree should
+  // look like — a folder collapsed, a rename ended — none of which the store
+  // snapshot can show, so the signature check has to be bypassed.
+  const rerenderHandler = () => {
+    renderedSignature = null;
+    refresh();
+  };
+  document.addEventListener("catalog-rerender", rerenderHandler);
+
+  // The command bar's action page (#151) picks an action and hands it here:
+  // both flows are the ones the card already has, reached by session rather
+  // than by row.
+  const killHandler = (ev: Event) => {
+    const s = (ev as CustomEvent<Session>).detail;
+    requestKill(s, sessionName(s));
+  };
+  const renameHandler = (ev: Event) => {
+    const s = (ev as CustomEvent<Session>).detail;
+    const row = rowForSession(s);
+    if (row) beginRename(row, s);
+  };
+  document.addEventListener(KILL_SESSION_EVENT, killHandler);
+  document.addEventListener(RENAME_SESSION_EVENT, renameHandler);
+
+  /** The card a session is rendered as, expanding whatever folder hides it
+   *  first: the rename prompt lives inside the card, so a collapsed folder
+   *  would otherwise swallow the request. */
+  function rowForSession(s: Session): HTMLElement | null {
+    const find = () => treeHost.querySelector<HTMLElement>(`.tree-leaf[data-session-id="${s.id}"]`);
+    const found = find();
+    if (found) return found;
+    // Folder paths are the abbreviated directory's segments joined back up
+    // (see buildTree), so the session's own path is normalised the same way
+    // before it is compared against them.
+    const cwd = sessionTreePath(s);
+    const path = (cwd ? abbreviateCwd(cwd, homeDir) : "").split("/").filter(Boolean).join("/");
+    for (const folder of [...collapsed]) {
+      if (path === folder || path.startsWith(`${folder}/`)) collapsed.delete(folder);
+    }
+    rerenderHandler();
+    return find();
+  }
+
+  // "Spawn similar" (#28) is dispatched here and handled in main.ts, where the
+  // multi-view controller can seed the spawn modal with the session's dir/command.
+
+  const unsubscribe = store.subscribe(refresh);
+
+  // Contract granularity: re-render at least every 30s while visible so the
+  // duration cutover points land within one tick.
+  const clock = setInterval(() => {
+    if (document.visibilityState !== "visible") return;
+    refresh();
+  }, 30_000);
+
+  return {
+    el,
+    setActive(id: string | null) {
+      highlights = {
+        open: id ? new Set([id]) : new Set(),
+        focused: id,
+      };
+      applyHighlights();
+    },
+    setHighlights(h: SidebarHighlights) {
+      highlights = h;
+      applyHighlights();
+    },
+    setPreview(sessionId: string | null) {
+      previewing = sessionId;
+      applyHighlights();
+    },
+    focusList() {
+      // Start from the session on screen — that is where the user's attention
+      // already is — falling back to the standing highlight, then the top row.
+      const preferred = highlights.focused ? `session:${highlights.focused}` : null;
+      const start = rowFor(preferred) ?? rowFor(navKey) ?? navRows()[0];
+      navKey = start?.dataset.navKey ?? null;
+      applyNav();
+      treeHost.focus();
+      start?.scrollIntoView({ block: "nearest" });
+    },
+    hasListFocus() {
+      return treeHost.contains(document.activeElement);
+    },
+    dispose() {
+      clearInterval(clock);
+      status?.dispose();
+      // An unfinished rename would otherwise leave every later sidebar
+      // refusing to refresh.
+      renamingId = null;
+      document.removeEventListener("catalog-rerender", rerenderHandler);
+      document.removeEventListener(KILL_SESSION_EVENT, killHandler);
+      document.removeEventListener(RENAME_SESSION_EVENT, renameHandler);
+      unsubscribe();
+    },
+  };
+}

web/src/catalogPatch.test.ts

@@ -0,0 +1,105 @@
+// @vitest-environment happy-dom
+import { beforeAll, describe, expect, it } from "vitest";
+
+import { renderSidebar } from "./catalog.js";
+import type { CatalogListener, CatalogStore } from "./events.js";
+import type { Session } from "./types.js";
+
+beforeAll(() => {
+  Object.defineProperty(window, "localStorage", {
+    value: { getItem: () => null, setItem: () => {} },
+  });
+  window.fetch = () => Promise.reject(new Error("offline"));
+});
+
+const ID = "11111111-2222-3333-4444-555555555555";
+
+function session(overrides: Partial<Session> = {}): Session {
+  return {
+    id: ID,
+    cwd: "/home/naps/tea/maestro",
+    command: "claude",
+    env: {},
+    metadata: {},
+    status: "Running",
+    created_at: "2026-08-24T10:00:00Z",
+    ...overrides,
+  };
+}
+
+/** A store whose updates actually reach subscribers, unlike the one-shot
+ *  harness in catalog.test.ts. */
+function liveStore(initial: Session[]) {
+  const state = { sessions: new Map(initial.map((s) => [s.id, s])) };
+  const listeners = new Set<CatalogListener>();
+  const store = {
+    snapshot: () => state,
+    subscribe: (fn: CatalogListener) => {
+      listeners.add(fn);
+      fn(state);
+      return () => listeners.delete(fn);
+    },
+  } as unknown as CatalogStore;
+  const push = (sessions: Session[]) => {
+    state.sessions = new Map(sessions.map((s) => [s.id, s]));
+    for (const fn of listeners) fn(state);
+  };
+  return { store, push };
+}
+
+const rowOf = (el: HTMLElement) => el.querySelector<HTMLElement>(".tree-leaf")!;
+
+describe("sidebar refresh keeps rows in place (docs/SIDEBAR.md)", () => {
+  it("patches an activity change into the standing row instead of rebuilding it", () => {
+    const { store, push } = liveStore([session({ activity: "Idle" })]);
+    const { el } = renderSidebar(store, {});
+    const before = rowOf(el);
+
+    push([session({ activity: "AwaitingInput" })]);
+
+    // Same element: a rebuild under the pointer would drop `:hover` and restart
+    // the row's transitions, which is the flicker this avoids.
+    expect(rowOf(el)).toBe(before);
+    // …and the card still tells the truth about the session.
+    expect(before.querySelector(".activity-rail")?.getAttribute("data-activity")).toBe(
+      "awaiting-input",
+    );
+    expect(before.querySelector(".card-line2")?.getAttribute("data-activity")).toBe(
+      "awaiting-input",
+    );
+    expect(before.getAttribute("aria-label")).toContain("Awaiting input");
+  });
+
+  it("rebuilds when the row set changes", () => {
+    const { store, push } = liveStore([session()]);
+    const { el } = renderSidebar(store, {});
+    const before = rowOf(el);
+
+    push([session(), session({ id: "99999999-2222-3333-4444-555555555555", command: "bash" })]);
+
+    expect(el.querySelectorAll(".tree-leaf")).toHaveLength(2);
+    expect(rowOf(el)).not.toBe(before);
+  });
+
+  it("rebuilds when a session dies", () => {
+    const { store, push } = liveStore([session()]);
+    const { el } = renderSidebar(store, {});
+    const before = rowOf(el);
+
+    push([session({ status: "Dead" })]);
+
+    expect(rowOf(el)).not.toBe(before);
+    expect(rowOf(el).dataset.status).toBe("dead");
+  });
+
+  it("rebuilds when a session is renamed", () => {
+    const { store, push } = liveStore([session()]);
+    const { el } = renderSidebar(store, {});
+    const before = rowOf(el);
+
+    push([session({ metadata: { name: "harmony" } })]);
+
+    expect(rowOf(el)).not.toBe(before);
+    expect(rowOf(el).querySelector(".leaf-name")?.textContent).toBe("harmony");
+  });
+});

web/src/commandBar.test.ts

@@ -0,0 +1,737 @@
+// @vitest-environment happy-dom
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+import {
+  KILL_SESSION_EVENT,
+  RENAME_SESSION_EVENT,
+  SESSION_SELECT_EVENT,
+  SPAWN_SIMILAR_EVENT,
+} from "./catalog.js";
+import {
+  barGroups,
+  barRows,
+  closeCommandBar,
+  commandBarCandidates,
+  dedupeCommands,
+  directoryBarCandidates,
+  directoryCandidate,
+  isCommandBarOpen,
+  openCommandBar,
+  orderSessionsForBar,
+  parseBarQuery,
+  sessionBarCandidates,
+  sessionActionCandidates,
+  sessionCandidate,
+  SPAWN_DIRECTORY_EVENT,
+} from "./commandBar.js";
+import { COMMAND_SPECS, type Command } from "./commands.js";
+import type { Session } from "./types.js";
+
+function session(id: string, over: Partial<Session> = {}): Session {
+  return {
+    id,
+    cwd: "/home/me/dev/api",
+    command: "bash",
+    env: {},
+    metadata: { name: id },
+    status: "Running",
+    created_at: "2026-01-01T00:00:00Z",
+    ...over,
+  };
+}
+
+afterEach(() => {
+  closeCommandBar();
+  document.body.replaceChildren();
+});
+
+function press(key: string, init: KeyboardEventInit = {}): void {
+  const input = document.querySelector(".cmdbar-input") as HTMLInputElement;
+  input.dispatchEvent(new KeyboardEvent("keydown", { key, bubbles: true, ...init }));
+}
+
+function type(value: string): void {
+  const input = document.querySelector(".cmdbar-input") as HTMLInputElement;
+  input.value = value;
+  input.dispatchEvent(new Event("input", { bubbles: true }));
+}
+
+function rowNames(): string[] {
+  return [...document.querySelectorAll(".cmdbar-row-name")].map((r) => r.textContent ?? "");
+}
+
+function activeName(): string | undefined {
+  return document.querySelector(".cmdbar-row.is-active .cmdbar-row-name")?.textContent ?? undefined;
+}
+
+describe("empty-query ordering", () => {
+  it("sorts most recently focused first", () => {
+    const older = session("older", { last_focused_at: "2026-01-01T10:00:00Z" });
+    const newer = session("newer", { last_focused_at: "2026-01-01T11:00:00Z" });
+    expect(orderSessionsForBar([older, newer]).map((s) => s.id)).toEqual(["newer", "older"]);
+  });
+
+  it("sorts a never-focused session after every focused one, newest created first", () => {
+    const focused = session("focused", {
+      last_focused_at: "2020-01-01T00:00:00Z",
+      created_at: "2020-01-01T00:00:00Z",
+    });
+    const oldFresh = session("old-fresh", { created_at: "2026-01-01T00:00:00Z" });
+    const newFresh = session("new-fresh", { created_at: "2026-06-01T00:00:00Z" });
+    expect(orderSessionsForBar([oldFresh, newFresh, focused]).map((s) => s.id)).toEqual([
+      "focused",
+      "new-fresh",
+      "old-fresh",
+    ]);
+  });
+
+  it("sorts dead sessions after live ones regardless of recency", () => {
+    const deadRecent = session("dead", {
+      status: "Dead",
+      last_focused_at: "2026-06-01T00:00:00Z",
+    });
+    const liveStale = session("live", { last_focused_at: "2020-01-01T00:00:00Z" });
+    const liveNever = session("never");
+    expect(orderSessionsForBar([deadRecent, liveNever, liveStale]).map((s) => s.id)).toEqual([
+      "live",
+      "never",
+      "dead",
+    ]);
+  });
+
+  // #162: docs/COMMAND-BAR.md ranks by whether you could attach, not by which
+  // way the pane went away.
+  it("sorts dormant sessions after live ones, like dead ones", () => {
+    const dormantRecent = session("dormant", {
+      status: "Dormant",
+      last_focused_at: "2026-06-01T00:00:00Z",
+    });
+    const liveStale = session("live", { last_focused_at: "2020-01-01T00:00:00Z" });
+    expect(orderSessionsForBar([dormantRecent, liveStale]).map((s) => s.id)).toEqual([
+      "live",
+      "dormant",
+    ]);
+  });
+
+  it("treats a null last_focused_at as never focused", () => {
+    const nulled = session("nulled", { last_focused_at: null });
+    const stamped = session("stamped", { last_focused_at: "2020-01-01T00:00:00Z" });
+    expect(orderSessionsForBar([nulled, stamped]).map((s) => s.id)).toEqual(["stamped", "nulled"]);
+  });
+});
+
+describe("session candidates", () => {
+  it("carries the candidate table's fields, with the directory abbreviated", () => {
+    const s = session("api", {
+      metadata: { name: "api" },
+      command: "claude --resume",
+      current_cwd: "/home/me/dev/api",
+    });
+    expect(sessionCandidate(s, "/home/me")).toEqual({
+      kind: "session",
+      session: s,
+      fields: {
+        name: "api",
+        directory: "~/dev/api",
+        command: "claude --resume",
+        tool: "claude",
+      },
+    });
+  });
+
+  it("leaves the tool out when the program has no mark, and groups a worktree by its repo", () => {
+    const s = session("edit", {
+      metadata: {},
+      command: "hx src/",
+      worktree: { path: "/home/me/dev/api/wt/x", base_repo: "/home/me/dev/api" },
+    });
+    const candidate = sessionCandidate(s, "/home/me");
+    expect(candidate.fields.tool).toBeUndefined();
+    expect(candidate.fields.directory).toBe("~/dev/api");
+    // No `metadata.name`: the sidebar's fallback is the command line.
+    expect(candidate.fields.name).toBe("hx src/");
+  });
+
+  it("builds candidates in the empty-query order", () => {
+    const a = session("a", { last_focused_at: "2026-01-01T10:00:00Z" });
+    const b = session("b", { last_focused_at: "2026-01-01T11:00:00Z" });
+    expect(sessionBarCandidates([a, b]).map((c) => c.session.id)).toEqual(["b", "a"]);
+  });
+});
+
+describe("rows and grouping", () => {
+  it("an empty query keeps every session in input order", () => {
+    const candidates = sessionBarCandidates([session("a"), session("b")]);
+    expect(barRows("", candidates).map((r) => r.candidate.session.id)).toEqual(["a", "b"]);
+  });
+
+  it("groups by kind without reordering the ranking", () => {
+    const candidates = sessionBarCandidates([
+      session("worker", { metadata: { name: "worker" }, current_cwd: "/home/me/dev/api" }),
+      session("api", { metadata: { name: "api" }, current_cwd: "/home/me/dev/web" }),
+    ]);
+    const rows = barRows("api", candidates);
+    const groups = barGroups(rows);
+    expect(groups).toHaveLength(1);
+    expect(groups[0].title).toBe("Sessions");
+    expect(groups[0].results.map((r) => r.candidate.session.id)).toEqual(
+      rows.map((r) => r.candidate.session.id),
+    );
+    // F6: the name beats the directory, and the directory match highlights
+    // inside the directory.
+    expect(groups[0].results[0].candidate.session.id).toBe("api");
+    expect(groups[0].results[1].field).toBe("directory");
+  });
+});
+
+describe("the overlay", () => {
+  const sessions = [
+    session("api", {
+      metadata: { name: "api" },
+      current_cwd: "/home/me/dev/api",
+      last_focused_at: "2026-01-01T11:00:00Z",
+    }),
+    session("worker", {
+      metadata: { name: "worker" },
+      current_cwd: "/home/me/dev/worker",
+      last_focused_at: "2026-01-01T10:00:00Z",
+    }),
+    session("notes", { metadata: { name: "notes" }, current_cwd: "/home/me/notes" }),
+  ];
+
+  // Sessions only: the mixed list's command half is the sigil describe's
+  // business, and the registry is whatever another test file happened to bind.
+  function open(over: Parameters<typeof openCommandBar>[0] | null = null) {
+    return openCommandBar(
+      over ?? { sessions, homeDir: "/home/me", commands: [], onOpenSession: () => {} },
+    );
+  }
+
+  it("is a registry command, so the help overlay lists it", () => {
+    const spec = COMMAND_SPECS.find((s) => s.id === "bar.open");
+    expect(spec?.keys).toEqual(["ctrl-k"]);
+    expect(spec?.scope).toBe("global");
+  });
+
+  it("lists sessions by recency under a kind header on an empty query", () => {
+    open();
+    expect([...document.querySelectorAll(".cmdbar-group-title")].map((h) => h.textContent)).toEqual([
+      "Sessions",
+    ]);
+    expect(rowNames()).toEqual(["api", "worker", "notes"]);
+    expect(activeName()).toBe("api");
+  });
+
+  it("opening twice leaves one overlay", () => {
+    open();
+    open();
+    expect(document.querySelectorAll(".cmdbar-overlay")).toHaveLength(1);
+    expect(isCommandBarOpen()).toBe(true);
+  });
+
+  it("ranks a typed query through the matcher and highlights the matched range", () => {
+    open();
+    type("wor");
+    expect(rowNames()).toEqual(["worker"]);
+    const marks = [...document.querySelectorAll(".cmdbar-row-name mark")].map((m) => m.textContent);
+    expect(marks).toEqual(["wor"]);
+  });
+
+  it("highlights inside the directory when that is the field that matched", () => {
+    open();
+    type("notes");
+    const row = document.querySelector(".cmdbar-row") as HTMLElement;
+    expect(row.dataset.sessionId).toBe("notes");
+    type("dev/wor");
+    expect(rowNames()).toEqual(["worker"]);
+    expect(
+      [...document.querySelectorAll(".cmdbar-row-meta mark")].map((m) => m.textContent).join(""),
+    ).toBe("dev/wor");
+  });
+
+  it("renders a no-results state rather than an empty list", () => {
+    open();
+    type("zzz");
+    expect(rowNames()).toEqual([]);
+    expect(document.querySelector(".cmdbar-empty")?.textContent).toBe("No matches");
+  });
+
+  it("moves the highlight with the arrows and ctrl-p/ctrl-n, without wrapping", () => {
+    open();
+    press("ArrowUp");
+    expect(activeName()).toBe("api");
+    press("ArrowDown");
+    expect(activeName()).toBe("worker");
+    press("n", { ctrlKey: true });
+    expect(activeName()).toBe("notes");
+    press("ArrowDown");
+    expect(activeName()).toBe("notes");
+    press("p", { ctrlKey: true });
+    expect(activeName()).toBe("worker");
+  });
+
+  it("puts the highlight back on the best row whenever the query changes", () => {
+    open();
+    press("ArrowDown");
+    expect(activeName()).toBe("worker");
+    type("o");
+    expect(activeName()).toBe(document.querySelector(".cmdbar-row-name")?.textContent);
+  });
+
+  it("opens the highlighted session through the shared open path on Enter", () => {
+    const seen: string[] = [];
+    const listener = (e: Event) => seen.push((e as CustomEvent<string>).detail);
+    document.addEventListener(SESSION_SELECT_EVENT, listener);
+    openCommandBar({ sessions, homeDir: "/home/me", commands: [] });
+    press("ArrowDown");
+    press("Enter");
+    document.removeEventListener(SESSION_SELECT_EVENT, listener);
+    expect(seen).toEqual(["worker"]);
+    expect(isCommandBarOpen()).toBe(false);
+  });
+
+  it("Enter on an empty result list does nothing", () => {
+    const onOpenSession = vi.fn();
+    open({ sessions, homeDir: "/home/me", commands: [], onOpenSession });
+    type("zzz");
+    press("Enter");
+    expect(onOpenSession).not.toHaveBeenCalled();
+    expect(isCommandBarOpen()).toBe(true);
+  });
+
+  it("closes on Escape and on a press outside the panel", () => {
+    open();
+    press("Escape");
+    expect(isCommandBarOpen()).toBe(false);
+
+    open();
+    (document.querySelector(".cmdbar-overlay") as HTMLElement).dispatchEvent(
+      new MouseEvent("mousedown", { bubbles: true }),
+    );
+    expect(isCommandBarOpen()).toBe(false);
+  });
+
+  it("stays open for a press inside the panel", () => {
+    open();
+    (document.querySelector(".cmdbar-panel") as HTMLElement).dispatchEvent(
+      new MouseEvent("mousedown", { bubbles: true }),
+    );
+    expect(isCommandBarOpen()).toBe(true);
+  });
+
+  it("returns the keyboard to whatever held it when it opened", () => {
+    const before = document.createElement("button");
+    document.body.appendChild(before);
+    before.focus();
+    open();
+    expect(document.activeElement).toBe(document.querySelector(".cmdbar-input"));
+    press("Escape");
+    expect(document.activeElement).toBe(before);
+  });
+
+  it("clicking a row opens that session", () => {
+    const onOpenSession = vi.fn();
+    open({ sessions, homeDir: "/home/me", commands: [], onOpenSession });
+    (document.querySelectorAll(".cmdbar-row")[1] as HTMLElement).click();
+    expect(onOpenSession).toHaveBeenCalledWith("worker");
+    expect(isCommandBarOpen()).toBe(false);
+  });
+});
+
+// ---- the sigils (#150) ----
+
+function command(id: string, label: string, keys: string[], run = () => {}): Command {
+  return { id, label, group: "Test", keys, scope: "global", run };
+}
+
+const flush = () => new Promise((resolve) => setTimeout(resolve, 0));
+
+function rowKeys(): string[][] {
+  return [...document.querySelectorAll(".cmdbar-row-keys")].map((el) =>
+    [...el.querySelectorAll("kbd")].map((k) => k.textContent ?? ""),
+  );
+}
+
+describe("parsing the query line", () => {
+  it("reads a sigil only in first position", () => {
+    expect(parseBarQuery(">kill")).toEqual({ sigil: ">", query: "kill" });
+    expect(parseBarQuery("~/dev")).toEqual({ sigil: "~", query: "/dev" });
+    expect(parseBarQuery("")).toEqual({ sigil: null, query: "" });
+    expect(parseBarQuery("api")).toEqual({ sigil: null, query: "api" });
+  });
+
+  it("leaves a sigil character elsewhere in the query literal", () => {
+    expect(parseBarQuery("api>x")).toEqual({ sigil: null, query: "api>x" });
+    // The case that matters: the second `~` of a directory query reaches the
+    // matcher.
+    expect(parseBarQuery("~~/dev")).toEqual({ sigil: "~", query: "~/dev" });
+  });
+
+  it("returns to the mixed list when the sigil is backspaced away", () => {
+    expect(parseBarQuery(">").sigil).toBe(">");
+    expect(parseBarQuery("").sigil).toBeNull();
+  });
+});
+
+describe("command candidates", () => {
+  it("dedupes by action, not by chord", () => {
+    const run = () => {};
+    const kill = command("a.kill", "Kill the session", ["x"], run);
+    const alias = command("b.kill", "Kill the session", ["ctrl-x"], run);
+    const other = command("c.rename", "Rename the session", ["r"]);
+    expect(dedupeCommands([kill, alias, other]).map((c) => c.id)).toEqual(["a.kill", "c.rename"]);
+  });
+
+  it("matches on the label only, and keeps the chord for display", () => {
+    const candidates = commandBarCandidates([command("a", "Open the spawn form", ["ctrl-k"])]);
+    expect(candidates[0].fields).toEqual({ label: "Open the spawn form" });
+    expect(candidates[0].command.keys).toEqual(["ctrl-k"]);
+  });
+});
+
+describe("directory candidates", () => {
+  it("abbreviates the path it shows and keeps the one it spawns in", () => {
+    const c = directoryCandidate("/home/me/dev/api", "/home/me");
+    expect(c).toEqual({ kind: "directory", path: "/home/me/dev/api", fields: { path: "~/dev/api" } });
+  });
+
+  it("expands a typed `~` and dedupes by the directory spawned in", () => {
+    const paths = ["~/dev/api", "/home/me/dev/api", "/tmp/scratch"];
+    expect(directoryBarCandidates(paths, "/home/me").map((c) => c.path)).toEqual([
+      "/home/me/dev/api",
+      "/tmp/scratch",
+    ]);
+  });
+});
+
+describe("the sigils in the overlay", () => {
+  const sessions = [session("api", { metadata: { name: "api" }, current_cwd: "/home/me/dev/api" })];
+  const ran: string[] = [];
+  const commands = [
+    command("spawn.open", "Open the spawn form", ["n"], () => ran.push("spawn.open")),
+    command("list.kill", "Kill the highlighted session", ["x"], () => ran.push("list.kill")),
+  ];
+
+  afterEach(() => {
+    ran.length = 0;
+  });
+
+  function open(over: Partial<Parameters<typeof openCommandBar>[0]> = {}) {
+    return openCommandBar({
+      sessions,
+      homeDir: "/home/me",
+      commands,
+      onOpenSession: () => {},
+      loadDirectories: async () => [],
+      listDirEntries: async () => [],
+      onSpawnDirectory: () => {},
+      ...over,
+    });
+  }
+
+  it("lists every command in registry order under `>`, with its chord and no header", () => {
+    open();
+    type(">");
+    expect(rowNames()).toEqual(["Open the spawn form", "Kill the highlighted session"]);
+    expect(rowKeys()).toEqual([["n"], ["x"]]);
+    expect(document.querySelectorAll(".cmdbar-group-title")).toHaveLength(0);
+  });
+
+  it("matches a command on its label and never on its chord", () => {
+    open();
+    type(">kill");
+    expect(rowNames()).toEqual(["Kill the highlighted session"]);
+    // `n` and `x` are chords, not label text: querying one finds nothing that
+    // the label does not also justify.
+    type(">ctrlx");
+    expect(rowNames()).toEqual([]);
+  });
+
+  it("runs the highlighted command on Enter", () => {
+    open();
+    type(">kill");
+    press("Enter");
+    expect(ran).toEqual(["list.kill"]);
+    expect(isCommandBarOpen()).toBe(false);
+  });
+
+  it("keeps the list mixed with no sigil, and returns to it when the sigil goes", () => {
+    open();
+    type("s");
+    expect([...document.querySelectorAll(".cmdbar-group-title")].map((h) => h.textContent)).toEqual([
+      "Sessions",
+      "Commands",
+    ]);
+    type(">spawn");
+    expect(rowNames()).toEqual(["Open the spawn form"]);
+    // Backspacing the sigil away is ordinary editing.
+    type("spawn");
+    expect(rowNames()).toContain("Open the spawn form");
+    type("");
+    expect(rowNames()).toEqual(["api"]);
+  });
+
+  it("lists recent dirs then projects under `~`", async () => {
+    open({ loadDirectories: async () => ["/home/me/dev/api", "/srv/www"] });
+    type("~");
+    await flush();
+    expect(rowNames()).toEqual(["~/dev/api", "/srv/www"]);
+    expect(document.querySelectorAll(".cmdbar-group-title")).toHaveLength(0);
+  });
+
+  it("fills the list in from /api/dirs as a path is typed", async () => {
+    const asked: string[] = [];
+    open({
+      loadDirectories: async () => ["/home/me/notes"],
+      listDirEntries: async (dir) => {
+        asked.push(dir);
+        return ["maestro", "api"];
+      },
+    });
+    // The second `~` is a literal query character and reaches the matcher.
+    type("~~/dev/mae");
+    await flush();
+    expect(asked).toEqual(["~/dev/"]);
+    expect(rowNames()).toEqual(["~/dev/maestro"]);
+  });
+
+  it("spawns in the highlighted directory on Enter", async () => {
+    const spawned: string[] = [];
+    open({
+      loadDirectories: async () => ["~/dev/api"],
+      onSpawnDirectory: (path) => spawned.push(path),
+    });
+    type("~api");
+    await flush();
+    press("Enter");
+    expect(spawned).toEqual(["/home/me/dev/api"]);
+    expect(isCommandBarOpen()).toBe(false);
+  });
+
+  it("raises the spawn event when the caller supplies no handler", async () => {
+    const seen: string[] = [];
+    const listener = (e: Event) => seen.push((e as CustomEvent<string>).detail);
+    document.addEventListener(SPAWN_DIRECTORY_EVENT, listener);
+    openCommandBar({
+      sessions,
+      homeDir: "/home/me",
+      commands,
+      onOpenSession: () => {},
+      loadDirectories: async () => ["/home/me/dev/api"],
+      listDirEntries: async () => [],
+    });
+    type("~");
+    await flush();
+    press("Enter");
+    document.removeEventListener(SPAWN_DIRECTORY_EVENT, listener);
+    expect(seen).toEqual(["/home/me/dev/api"]);
+  });
+});
+
+describe("the focus round-trip over a pane (#152)", () => {
+  function terminalTextarea(): HTMLTextAreaElement {
+    const ta = document.createElement("textarea");
+    ta.className = "xterm-helper-textarea";
+    document.body.appendChild(ta);
+    return ta;
+  }
+
+  it("hands the keyboard back to the terminal that had it", () => {
+    const ta = terminalTextarea();
+    ta.focus();
+    openCommandBar({ sessions: [], commands: [] });
+    expect(document.activeElement).toBe(document.querySelector(".cmdbar-input"));
+    press("Escape");
+    expect(document.activeElement).toBe(ta);
+  });
+
+  it("reports no focus change to the daemon, opening or closing", () => {
+    const fetchMock = vi.fn(() => Promise.resolve(new Response(null, { status: 204 })));
+    vi.stubGlobal("fetch", fetchMock);
+    try {
+      const ta = terminalTextarea();
+      ta.focus();
+      openCommandBar({ sessions: [], commands: [] });
+      press("Escape");
+      const focusCalls = fetchMock.mock.calls.filter(([url]: unknown[]) =>
+        String(url).includes("/focus"),
+      );
+      expect(focusCalls).toEqual([]);
+    } finally {
+      vi.unstubAllGlobals();
+    }
+  });
+});
+
+describe("the session action page (#151)", () => {
+  const sessions = [
+    session("api", {
+      metadata: { name: "api" },
+      current_cwd: "/home/me/dev/api",
+      last_focused_at: "2026-01-01T11:00:00Z",
+    }),
+    session("worker", {
+      metadata: { name: "worker" },
+      current_cwd: "/home/me/dev/worker",
+      last_focused_at: "2026-01-01T10:00:00Z",
+    }),
+  ];
+
+  function open(over: Partial<Parameters<typeof openCommandBar>[0]> = {}) {
+    return openCommandBar({
+      sessions,
+      homeDir: "/home/me",
+      commands: [],
+      onOpenSession: () => {},
+      ...over,
+    });
+  }
+
+  function headerText(): string | undefined {
+    return document.querySelector(".cmdbar-page-header")?.textContent ?? undefined;
+  }
+
+  it("lists kill, rename and spawn similar for the highlighted session", () => {
+    open();
+    press("Tab");
+    expect(rowNames()).toEqual(["Kill session", "Rename session", "Spawn similar"]);
+    expect(activeName()).toBe("Kill session");
+  });
+
+  it("names the session being acted on", () => {
+    open();
+    press("ArrowDown");
+    press("Tab");
+    expect(headerText()).toContain("worker");
+  });
+
+  it("drops the kind headers, since the page is one kind", () => {
+    open();
+    press("Tab");
+    expect(document.querySelectorAll(".cmdbar-group-title")).toHaveLength(0);
+  });
+
+  it("stays fuzzy-searchable over the three actions", () => {
+    open();
+    press("Tab");
+    type("ren");
+    expect(rowNames()).toEqual(["Rename session"]);
+    type("spwn");
+    expect(rowNames()).toEqual(["Spawn similar"]);
+    type("zzz");
+    expect(document.querySelector(".cmdbar-empty")?.textContent).toBe("No matches");
+  });
+
+  it("does nothing on a command row", () => {
+    openCommandBar({
+      sessions,
+      homeDir: "/home/me",
+      commands: [{ ...COMMAND_SPECS[0], run: () => {} } as Command],
+      onOpenSession: () => {},
+    });
+    type(">");
+    const before = rowNames();
+    press("Tab");
+    expect(rowNames()).toEqual(before);
+    expect(headerText()).toBeUndefined();
+  });
+
+  it("does nothing on a directory row", async () => {
+    open({ loadDirectories: () => Promise.resolve(["/home/me/dev/api"]) });
+    type("~");
+    await Promise.resolve();
+    press("Tab");
+    expect(rowNames()).toEqual(["~/dev/api"]);
+    expect(headerText()).toBeUndefined();
+  });
+
+  it("returns to the result list on Escape, with the previous query intact", () => {
+    open();
+    type("wor");
+    press("Tab");
+    expect(headerText()).toContain("worker");
+    press("Escape");
+    expect(isCommandBarOpen()).toBe(true);
+    expect(headerText()).toBeUndefined();
+    expect((document.querySelector(".cmdbar-input") as HTMLInputElement).value).toBe("wor");
+    expect(rowNames()).toEqual(["worker"]);
+  });
+
+  it("returns to the result list on backspace at an empty query", () => {
+    open();
+    type("wor");
+    press("Tab");
+    type("");
+    press("Backspace");
+    expect(headerText()).toBeUndefined();
+    expect((document.querySelector(".cmdbar-input") as HTMLInputElement).value).toBe("wor");
+    expect(rowNames()).toEqual(["worker"]);
+  });
+
+  it("keeps backspace ordinary while the page's query has text", () => {
+    open();
+    press("Tab");
+    type("ren");
+    press("Backspace");
+    expect(headerText()).toContain("api");
+    expect(rowNames()).toEqual(["Rename session"]);
+  });
+
+  it("closes the bar when the page's Escape has already been used", () => {
+    open();
+    press("Tab");
+    press("Escape");
+    press("Escape");
+    expect(isCommandBarOpen()).toBe(false);
+  });
+
+  it("raises kill, rename and spawn similar with the session, closing the bar", () => {
+    const seen: string[] = [];
+    for (const [hook, key] of [
+      ["onKillSession", "Kill session"],
+      ["onRenameSession", "Rename session"],
+      ["onSpawnSimilar", "Spawn similar"],
+    ] as const) {
+      open({ [hook]: (s: Session) => seen.push(`${hook}:${s.id}`) });
+      type("wor");
+      press("Tab");
+      type(key);
+      press("Enter");
+      expect(isCommandBarOpen()).toBe(false);
+    }
+    expect(seen).toEqual([
+      "onKillSession:worker",
+      "onRenameSession:worker",
+      "onSpawnSimilar:worker",
+    ]);
+  });
+
+  it("hands each action to the flow it already has, by default", () => {
+    const seen: string[] = [];
+    const listeners: Array<[string, EventListener]> = [
+      [KILL_SESSION_EVENT, (e) => seen.push(`kill:${(e as CustomEvent<Session>).detail.id}`)],
+      [RENAME_SESSION_EVENT, (e) => seen.push(`rename:${(e as CustomEvent<Session>).detail.id}`)],
+      [SPAWN_SIMILAR_EVENT, (e) => seen.push(`similar:${(e as CustomEvent<Session>).detail.id}`)],
+    ];
+    for (const [name, fn] of listeners) document.addEventListener(name, fn);
+    try {
+      for (const action of ["Kill session", "Rename session", "Spawn similar"]) {
+        open();
+        press("Tab");
+        type(action);
+        press("Enter");
+      }
+    } finally {
+      for (const [name, fn] of listeners) document.removeEventListener(name, fn);
+    }
+    expect(seen).toEqual(["kill:api", "rename:api", "similar:api"]);
+  });
+
+  it("offers no action beyond the three", () => {
+    expect(sessionActionCandidates().map((c) => c.action.id)).toEqual([
+      "kill",
+      "rename",
+      "spawn-similar",
+    ]);
+  });
+});

web/src/commandBar.ts

@@ -0,0 +1,811 @@
+// The `ctrl-k` command bar (docs/COMMAND-BAR.md): a query line over a result
+// list, opened from the sidebar, closed with Escape.
+//
+// Three kinds live here: sessions and commands, ranked together by default,
+// and directories, which need the `~` sigil. `tab` on a session drills into
+// its action page (#151), which is the same overlay over three actions.
+
+import { listDir, projects as fetchProjects, recentDirs } from "./api.js";
+import {
+  KILL_SESSION_EVENT,
+  RENAME_SESSION_EVENT,
+  SESSION_SELECT_EVENT,
+  SPAWN_SIMILAR_EVENT,
+} from "./catalog.js";
+import { keyCaps, publishedCommands, type Command } from "./commands.js";
+import {
+  matchAndRank,
+  type CandidateKind,
+  type CommandCandidate,
+  type DirectoryCandidate,
+  type MatchRange,
+  type MatchResult,
+  type SessionCandidate,
+} from "./matcher.js";
+import { splitPath } from "./paths.js";
+import { splitCommand } from "./toolIcon.js";
+import { abbreviateCwd, sessionName, sessionTreePath, type Session } from "./types.js";
+
+/** A matcher candidate that remembers what it came from, so a result can be
+ *  acted on without a second lookup. The extra property is invisible to the
+ *  matcher, which only ever reads `kind` and `fields`. */
+export type SessionBarCandidate = SessionCandidate & { session: Session };
+export type CommandBarCandidate = CommandCandidate & { command: Command };
+/** `fields.path` is the abbreviated path the operator reads and the matcher
+ *  ranks; `path` is the one a spawn is made in. */
+export type DirectoryBarCandidate = DirectoryCandidate & { path: string };
+
+/** One row of a session's action page. It is a `command` to the matcher — a
+ *  single `label` field, ranked exactly like a registry command — and carries
+ *  the action it stands for instead of a registry entry. */
+export type ActionBarCandidate = CommandCandidate & { action: SessionAction };
+
+export type BarCandidate =
+  SessionBarCandidate | CommandBarCandidate | ActionBarCandidate | DirectoryBarCandidate;
+export type BarResult = MatchResult<BarCandidate>;
+
+/** Raised when Enter lands on a directory row. The bar picks the directory; the
+ *  shell owns the spawn, which is the same fast-forward path `N` takes. */
+export const SPAWN_DIRECTORY_EVENT = "cmdbar-spawn-directory";
+
+/** One kind's slice of the ranked list, in rank order. */
+export interface BarGroup<C extends BarCandidate = BarCandidate> {
+  kind: CandidateKind;
+  title: string;
+  results: MatchResult<C>[];
+}
+
+const KIND_TITLES: Record<CandidateKind, string> = {
+  session: "Sessions",
+  command: "Commands",
+  directory: "Directories",
+};
+
+// ---- the sigils ----
+
+export type BarSigil = ">" | "~";
+
+export interface BarQuery {
+  /** The sigil in force, or null for the mixed list. */
+  sigil: BarSigil | null;
+  /** What the matcher sees: everything after a sigil, or the whole query. */
+  query: string;
+}
+
+/** Split a raw query line into its sigil and the query proper.
+ *
+ *  A sigil is only a sigil in first position: `>` or `~` anywhere else is a
+ *  literal query character, which is what a directory query with a second `~`
+ *  in it depends on. Backspacing past a sigil needs no special case either —
+ *  the first character goes and the query is a mixed one again. */
+export function parseBarQuery(raw: string): BarQuery {
+  const first = raw[0];
+  if (first === ">" || first === "~") return { sigil: first, query: raw.slice(1) };
+  return { sigil: null, query: raw };
+}
+
+// ---- the session action page ----
+
+/** The actions a session's action page offers, and no others: the bar picks
+ *  one and hands off to the flow that already implements it
+ *  (docs/COMMAND-BAR.md, "Drill-in"). */
+export type SessionActionId = "kill" | "rename" | "spawn-similar";
+
+export interface SessionAction {
+  id: SessionActionId;
+  label: string;
+}
+
+export const SESSION_ACTIONS: readonly SessionAction[] = [
+  { id: "kill", label: "Kill session" },
+  { id: "rename", label: "Rename session" },
+  { id: "spawn-similar", label: "Spawn similar" },
+];
+
+/** The action page's candidates, in the order above — which is the order an
+ *  empty query lists them in, since the matcher keeps input order. */
+export function sessionActionCandidates(): ActionBarCandidate[] {
+  return SESSION_ACTIONS.map((action) => ({
+    kind: "command",
+    action,
+    fields: { label: action.label },
+  }));
+}
+
+/** Narrow a `command` candidate to an action row. Both share the matcher's
+ *  `command` kind, so what separates them is what they carry. */
+export function isActionCandidate(candidate: BarCandidate): candidate is ActionBarCandidate {
+  return candidate.kind === "command" && "action" in candidate;
+}
+
+// ---- candidates ----
+
+function focusedAt(s: Session): number | null {
+  const stamp = s.last_focused_at;
+  if (typeof stamp !== "string" || stamp === "") return null;
+  const ms = Date.parse(stamp);
+  return Number.isNaN(ms) ? null : ms;
+}
+
+function createdAt(s: Session): number {
+  const ms = Date.parse(s.created_at ?? "");
+  return Number.isNaN(ms) ? 0 : ms;
+}
+
+/** The empty-query order (docs/COMMAND-BAR.md, "Empty query"): most recently
+ *  focused first; a session that has never been focused sorts after every
+ *  session that has, most recently created first among those; and a dead
+ *  session sorts after every live one regardless of recency, because a session
+ *  you cannot attach to is not where you just were.
+ *
+ *  This is also the input order for a non-empty query, which is what the
+ *  matcher's last tie-break preserves. */
+export function orderSessionsForBar(sessions: readonly Session[]): Session[] {
+  return [...sessions].sort((a, b) => {
+    // docs/COMMAND-BAR.md: anything with no live pane — dead or dormant (#162)
+    // — sorts after the sessions you could actually attach to.
+    const deadA = a.status === "Running" ? 0 : 1;
+    const deadB = b.status === "Running" ? 0 : 1;
+    if (deadA !== deadB) return deadA - deadB;
+
+    const focusA = focusedAt(a);
+    const focusB = focusedAt(b);
+    if ((focusA === null) !== (focusB === null)) return focusA === null ? 1 : -1;
+    if (focusA !== null && focusB !== null && focusA !== focusB) return focusB - focusA;
+
+    return createdAt(b) - createdAt(a);
+  });
+}
+
+/** Build one session's candidate: the fields docs/COMMAND-BAR.md's candidate
+ *  table names, with the directory abbreviated the way the sidebar shows it. */
+export function sessionCandidate(s: Session, homeDir?: string): SessionBarCandidate {
+  const treePath = sessionTreePath(s);
+  const directory = treePath ? abbreviateCwd(treePath, homeDir) : undefined;
+  const tool = splitCommand(s.command).tool ?? undefined;
+  return {
+    kind: "session",
+    session: s,
+    fields: {
+      name: sessionName(s),
+      ...(directory ? { directory } : {}),
+      ...(s.command ? { command: s.command } : {}),
+      ...(tool ? { tool } : {}),
+    },
+  };
+}
+
+/** Every session as a candidate, in the empty-query order. */
+export function sessionBarCandidates(
+  sessions: readonly Session[],
+  homeDir?: string,
+): SessionBarCandidate[] {
+  return orderSessionsForBar(sessions).map((s) => sessionCandidate(s, homeDir));
+}
+
+/** Drop the commands that would list twice. Several chords can be bound to one
+ *  action — the registry already carries its aliases on one entry, but nothing
+ *  stops two entries running the same handler, and listed naively that is two
+ *  identical rows. The dedupe is by **action**, never by chord: the chord is
+ *  displayed, so a command with two of them is still one row. */
+export function dedupeCommands(commands: readonly Command[]): Command[] {
+  const seenRun = new Set<Command["run"]>();
+  const seenLabel = new Set<string>();
+  const kept: Command[] = [];
+  for (const command of commands) {
+    if (seenRun.has(command.run) || seenLabel.has(command.label)) continue;
+    seenRun.add(command.run);
+    seenLabel.add(command.label);
+    kept.push(command);
+  }
+  return kept;
+}
+
+/** Every bound command as a candidate, in registry order. Only the label is a
+ *  field: the chord is displayed beside the row, never matched, because
+ *  matching it would make `>` results depend on a user's rebinds. */
+export function commandBarCandidates(commands: readonly Command[]): CommandBarCandidate[] {
+  return dedupeCommands(commands).map((command) => ({
+    kind: "command",
+    command,
+    fields: { label: command.label },
+  }));
+}
+
+/** `~/dev/api` back to `/home/me/dev/api` — the inverse of `abbreviateCwd`, for
+ *  a path the operator typed or `/api/dirs` completed. */
+export function expandHome(path: string, homeDir?: string): string {
+  if (!homeDir) return path;
+  if (path === "~") return homeDir;
+  return path.startsWith("~/") ? `${homeDir}${path.slice(1)}` : path;
+}
+
+export function directoryCandidate(path: string, homeDir?: string): DirectoryBarCandidate {
+  const absolute = expandHome(path, homeDir);
+  return { kind: "directory", path: absolute, fields: { path: abbreviateCwd(absolute, homeDir) } };
+}
+
+/** Candidates for `~`, deduped by the directory they spawn in and keeping the
+ *  first mention of each — recent dirs (newest first) ahead of the project
+ *  list, which is the empty-query order the contract asks for. */
+export function directoryBarCandidates(
+  paths: readonly string[],
+  homeDir?: string,
+): DirectoryBarCandidate[] {
+  const seen = new Set<string>();
+  const out: DirectoryBarCandidate[] = [];
+  for (const path of paths) {
+    if (path === "") continue;
+    const candidate = directoryCandidate(path, homeDir);
+    if (seen.has(candidate.path)) continue;
+    seen.add(candidate.path);
+    out.push(candidate);
+  }
+  return out;
+}
+
+/** The directory list the bar starts from: what the spawn form already knows —
+ *  `GET /api/recent-dirs` and the project list — either alone if the other
+ *  fails. */
+export async function loadBarDirectories(): Promise<string[]> {
+  const [recents, discovered] = await Promise.all([
+    recentDirs()
+      .then((r) => r.dirs.map((d) => d.cwd))
+      .catch(() => [] as string[]),
+    fetchProjects()
+      .then((list) => list.map((p) => p.path))
+      .catch(() => [] as string[]),
+  ]);
+  return [...recents, ...discovered];
+}
+
+// ---- grouping ----
+
+/** Bucket a ranked list by kind for rendering. Grouping is a rendering of the
+ *  ranking, never a reordering of it: a group holds its matches in rank order,
+ *  and groups appear in the order their best-scoring member does — so the first
+ *  row under the first header is the globally best result. */
+export function barGroups<C extends BarCandidate>(
+  results: readonly MatchResult<C>[],
+): BarGroup<C>[] {
+  const groups: BarGroup<C>[] = [];
+  for (const result of results) {
+    const kind = result.candidate.kind;
+    let group = groups.find((g) => g.kind === kind);
+    if (!group) {
+      group = { kind, title: KIND_TITLES[kind], results: [] };
+      groups.push(group);
+    }
+    group.results.push(result);
+  }
+  return groups;
+}
+
+/** The rows a query produces, flat and in rank order — what the highlight walks
+ *  and what Enter acts on. Headers are labels, not rows, so they are never in
+ *  this list. */
+export function barRows<C extends BarCandidate>(
+  query: string,
+  candidates: readonly C[],
+): MatchResult<C>[] {
+  return matchAndRank(query, candidates);
+}
+
+// ---- rendering ----
+
+/** Text with its matched ranges wrapped in `<mark>`. Ranges come from the
+ *  matcher as `[start, end)` character pairs over the field that won. */
+export function renderHighlighted(text: string, ranges: readonly MatchRange[]): DocumentFragment {
+  const frag = document.createDocumentFragment();
+  let cursor = 0;
+  for (const [start, end] of ranges) {
+    if (start > cursor) frag.append(text.slice(cursor, start));
+    const mark = document.createElement("mark");
+    mark.className = "cmdbar-hit";
+    mark.textContent = text.slice(start, end);
+    frag.append(mark);
+    cursor = end;
+  }
+  if (cursor < text.length) frag.append(text.slice(cursor));
+  return frag;
+}
+
+/** The name line of a row: the session's name, the command's label, or the
+ *  directory's path. */
+function rowName(candidate: BarCandidate): string {
+  switch (candidate.kind) {
+    case "session":
+      return candidate.fields.name;
+    case "command":
+      return candidate.fields.label;
+    case "directory":
+      return candidate.fields.path;
+  }
+}
+
+/** The secondary line under a session row: the field the match was found in
+ *  when that was not the name, so a session found through its directory says
+ *  so. Only sessions have one — a command shows keycaps instead, and a
+ *  directory's path is already the name. */
+function metaText(result: BarResult): string | undefined {
+  if (result.candidate.kind !== "session") return undefined;
+  const fields = result.candidate.fields;
+  switch (result.field) {
+    case "directory":
+      return fields.directory;
+    case "command":
+      return fields.command;
+    case "tool":
+      return fields.tool;
+    default:
+      return fields.directory;
+  }
+}
+
+function renderRow(result: BarResult, index: number): HTMLElement {
+  const candidate = result.candidate;
+  const row = document.createElement("div");
+  row.className = "cmdbar-row";
+  row.setAttribute("role", "option");
+  row.id = `cmdbar-row-${index}`;
+  row.dataset.index = String(index);
+  row.dataset.kind = candidate.kind;
+  if (candidate.kind === "session") {
+    row.dataset.sessionId = candidate.session.id;
+    if (candidate.session.status !== "Running") row.classList.add("is-dead");
+  } else if (isActionCandidate(candidate)) {
+    row.dataset.actionId = candidate.action.id;
+  } else if (candidate.kind === "command") {
+    row.dataset.commandId = candidate.command.id;
+  } else {
+    row.dataset.path = candidate.path;
+  }
+
+  const name = document.createElement("span");
+  name.className = "cmdbar-row-name";
+  const nameText = rowName(candidate);
+  const nameMatched =
+    result.field === "name" || result.field === "label" || result.field === "path";
+  name.append(nameMatched ? renderHighlighted(nameText, result.ranges) : nameText);
+  row.appendChild(name);
+
+  // The chord is teaching material, not a match target: it is rendered from
+  // the live registry entry and never fed to the matcher.
+  if (candidate.kind === "command" && !isActionCandidate(candidate)) {
+    const keys = document.createElement("span");
+    keys.className = "cmdbar-row-keys";
+    for (const cap of keyCaps(candidate.command.keys[0])) {
+      const kbd = document.createElement("kbd");
+      kbd.textContent = cap;
+      keys.appendChild(kbd);
+    }
+    row.appendChild(keys);
+    return row;
+  }
+
+  const meta = metaText(result);
+  if (meta) {
+    const el = document.createElement("span");
+    el.className = "cmdbar-row-meta";
+    const highlighted = result.field !== undefined && result.field !== "name";
+    el.append(highlighted ? renderHighlighted(meta, result.ranges) : meta);
+    row.appendChild(el);
+  }
+  return row;
+}
+
+const PLACEHOLDERS: Record<"mixed" | BarSigil, string> = {
+  mixed: "Go to a session…",
+  ">": "Run a command…",
+  "~": "Spawn in a directory…",
+};
+
+// ---- the overlay ----
+
+export interface CommandBarOptions {
+  /** Sessions to build candidates from, as the store has them right now. */
+  sessions: readonly Session[];
+  /** The daemon's home dir, for the directory field's `~/…` abbreviation. */
+  homeDir?: string;
+  /** Open the highlighted session. Defaults to the shared open path — the
+   *  sidebar's click event — which is what the contract requires; tests pass
+   *  their own. */
+  onOpenSession?: (sessionId: string) => void;
+  /** The command registry to list under `>`. Defaults to every bound command,
+   *  in registry order. */
+  commands?: readonly Command[];
+  /** The directory list behind `~`, fetched once on first use. */
+  loadDirectories?: () => Promise<string[]>;
+  /** One directory's subdirectories, for filling the list in as a path is
+   *  typed. Defaults to `GET /api/dirs`. */
+  listDirEntries?: (dir: string) => Promise<string[]>;
+  /** Spawn a session in the highlighted directory. Defaults to raising
+   *  `SPAWN_DIRECTORY_EVENT`, which the shell turns into a fast-forward
+   *  spawn. */
+  onSpawnDirectory?: (path: string) => void;
+  /** The action page's three actions (#151). Each defaults to raising the
+   *  event the flow that already implements it listens on — the sidebar's
+   *  confirm-and-blockers kill, its inline rename prompt, the spawn form
+   *  seeded from the session. The bar picks the action and nothing more. */
+  onKillSession?: (session: Session) => void;
+  onRenameSession?: (session: Session) => void;
+  onSpawnSimilar?: (session: Session) => void;
+}
+
+interface OpenBar {
+  el: HTMLElement;
+  dispose: () => void;
+}
+
+let current: OpenBar | null = null;
+
+export function isCommandBarOpen(): boolean {
+  return current !== null;
+}
+
+export function closeCommandBar(): void {
+  current?.dispose();
+}
+
+/** Mount the bar. Opening while one is up replaces it, so a stray second call
+ *  can never stack two overlays. */
+export function openCommandBar(opts: CommandBarOptions): HTMLElement {
+  closeCommandBar();
+
+  // Closing returns the keyboard to whatever held it when the bar opened: a
+  // round trip through the bar never silently moves focus.
+  const previouslyFocused = document.activeElement as HTMLElement | null;
+  const openSession =
+    opts.onOpenSession ??
+    ((id: string) => document.dispatchEvent(new CustomEvent(SESSION_SELECT_EVENT, { detail: id })));
+  const spawnDirectory =
+    opts.onSpawnDirectory ??
+    ((path: string) =>
+      document.dispatchEvent(new CustomEvent(SPAWN_DIRECTORY_EVENT, { detail: path })));
+  const sessionEvent =
+    (name: string) =>
+    (session: Session): void => {
+      document.dispatchEvent(new CustomEvent(name, { detail: session }));
+    };
+  const killSession = opts.onKillSession ?? sessionEvent(KILL_SESSION_EVENT);
+  const renameSession = opts.onRenameSession ?? sessionEvent(RENAME_SESSION_EVENT);
+  const spawnSimilar = opts.onSpawnSimilar ?? sessionEvent(SPAWN_SIMILAR_EVENT);
+  const loadDirectories = opts.loadDirectories ?? loadBarDirectories;
+  const listEntries =
+    opts.listDirEntries ?? ((dir: string) => listDir(dir).then((listing) => listing.entries));
+
+  const sessionCandidates: SessionBarCandidate[] = sessionBarCandidates(
+    opts.sessions,
+    opts.homeDir,
+  );
+  const commandCandidates: CommandBarCandidate[] = commandBarCandidates(
+    opts.commands ?? publishedCommands(),
+  );
+
+  const el = document.createElement("div");
+  el.className = "cmdbar-overlay";
+  el.setAttribute("role", "dialog");
+  el.setAttribute("aria-modal", "true");
+  el.setAttribute("aria-label", "Command bar");
+
+  const panel = document.createElement("div");
+  panel.className = "cmdbar-panel";
+
+  const input = document.createElement("input");
+  input.type = "text";
+  input.className = "cmdbar-input";
+  input.setAttribute("role", "combobox");
+  input.setAttribute("aria-expanded", "true");
+  input.setAttribute("aria-controls", "cmdbar-results");
+  input.setAttribute("aria-label", "Search sessions, commands and directories");
+  input.setAttribute("autocomplete", "off");
+  input.spellcheck = false;
+  input.placeholder = PLACEHOLDERS.mixed;
+
+  const results = document.createElement("div");
+  results.className = "cmdbar-results";
+  results.id = "cmdbar-results";
+  results.setAttribute("role", "listbox");
+
+  panel.append(input, results);
+  el.appendChild(panel);
+  document.body.appendChild(el);
+
+  let rows: BarResult[] = [];
+  let highlighted = 0;
+
+  // The action page (#151). `page` is the session being acted on, `stashed`
+  // the result-list query it was drilled into from — backing out restores it,
+  // so the round trip costs the operator nothing.
+  let page: Session | null = null;
+  let stashed = "";
+  let header: HTMLElement | null = null;
+
+  // `~`'s candidates: the recents-and-projects list, fetched once, plus
+  // whatever `/api/dirs` has filled in for the directory being typed.
+  let directories: DirectoryBarCandidate[] = [];
+  let directoriesRequested = false;
+  let probed: DirectoryBarCandidate[] = [];
+  let probedDir: string | null = null;
+  const listings = new Map<string, string[]>();
+
+  function alive(): boolean {
+    return current?.el === el;
+  }
+
+  /** Fetch the recents-and-projects list the first time `~` is used. */
+  function ensureDirectories(): void {
+    if (directoriesRequested) return;
+    directoriesRequested = true;
+    loadDirectories()
+      .then((paths) => {
+        directories = directoryBarCandidates(paths, opts.homeDir);
+        if (alive()) render();
+      })
+      .catch(() => {
+        /* no directories is a shorter list, not an error state */
+      });
+  }
+
+  /** Fill the list in from `GET /api/dirs` once the query looks like a path:
+   *  the directory it names is listed and its children join the candidates, so
+   *  `~` reaches a directory that was never spawned in. */
+  function probeDirectories(query: string): void {
+    const { dir } = splitPath(query);
+    if (dir === "") {
+      probed = [];
+      probedDir = null;
+      return;
+    }
+    if (dir === probedDir) return;
+    probedDir = dir;
+    const cached = listings.get(dir);
+    if (cached) {
+      probed = directoryBarCandidates(
+        cached.map((entry) => `${dir}${entry}`),
+        opts.homeDir,
+      );
+      return;
+    }
+    probed = [];
+    listEntries(dir)
+      .then((entries) => {
+        listings.set(dir, entries);
+        if (!alive() || probedDir !== dir) return;
+        probed = directoryBarCandidates(
+          entries.map((entry) => `${dir}${entry}`),
+          opts.homeDir,
+        );
+        render();
+      })
+      .catch(() => {
+        /* an unreadable directory contributes nothing */
+      });
+  }
+
+  /** What the matcher sees for the query line as it stands. With no sigil the
+   *  list is mixed — sessions and commands together — except on an empty query,
+   *  where the bar is a session switcher. */
+  function candidatesFor(parsed: BarQuery): BarCandidate[] {
+    if (page) return sessionActionCandidates();
+    switch (parsed.sigil) {
+      case ">":
+        return [...commandCandidates];
+      case "~": {
+        ensureDirectories();
+        probeDirectories(parsed.query);
+        const seen = new Set<string>();
+        return [...directories, ...probed].filter((c) =>
+          seen.has(c.path) ? false : (seen.add(c.path), true),
+        );
+      }
+      default:
+        return parsed.query === ""
+          ? [...sessionCandidates]
+          : [...sessionCandidates, ...commandCandidates];
+    }
+  }
+
+  function paintHighlight(): void {
+    for (const row of results.querySelectorAll<HTMLElement>(".cmdbar-row")) {
+      const active = Number(row.dataset.index) === highlighted;
+      row.classList.toggle("is-active", active);
+      row.setAttribute("aria-selected", active ? "true" : "false");
+      if (active) {
+        row.scrollIntoView({ block: "nearest" });
+        input.setAttribute("aria-activedescendant", row.id);
+      }
+    }
+    if (rows.length === 0) input.removeAttribute("aria-activedescendant");
+  }
+
+  /** The line naming the session being acted on, so the target is never
+   *  ambiguous. Present only while the action page is up. */
+  function paintHeader(): void {
+    header?.remove();
+    header = null;
+    if (!page) return;
+    header = document.createElement("div");
+    header.className = "cmdbar-page-header";
+    header.setAttribute("role", "presentation");
+    header.textContent = `Actions for "${sessionName(page)}"`;
+    panel.insertBefore(header, results);
+  }
+
+  function render(): void {
+    // On the action page the query line is over the three actions, so there is
+    // no sigil to read: `>` and `~` are ordinary characters there.
+    const parsed = page ? { sigil: null, query: input.value } : parseBarQuery(input.value);
+    input.placeholder = page
+      ? `Act on ${sessionName(page)}…`
+      : PLACEHOLDERS[parsed.sigil ?? "mixed"];
+    paintHeader();
+    rows = barRows(parsed.query, candidatesFor(parsed));
+    // The highlight starts on the globally best row every time the list
+    // changes: an old index would point at a different result.
+    highlighted = 0;
+    results.replaceChildren();
+
+    if (rows.length === 0) {
+      const empty = document.createElement("div");
+      empty.className = "cmdbar-empty";
+      empty.textContent = "No matches";
+      results.appendChild(empty);
+      paintHighlight();
+      return;
+    }
+
+    let index = 0;
+    for (const group of barGroups(rows)) {
+      // While a sigil is in force there is one kind, so the header is
+      // dropped — and the action page is one kind too.
+      if (parsed.sigil === null && !page) {
+        const header = document.createElement("div");
+        header.className = "cmdbar-group-title";
+        header.setAttribute("role", "presentation");
+        header.textContent = group.title;
+        results.appendChild(header);
+      }
+      for (const result of group.results) {
+        const at = index;
+        const row = renderRow(result, at);
+        row.addEventListener("click", () => activate(at));
+        results.appendChild(row);
+        index += 1;
+      }
+    }
+    paintHighlight();
+  }
+
+  /** The highlight does not wrap: it stops at the first and last row. */
+  function move(delta: number): void {
+    if (rows.length === 0) return;
+    highlighted = Math.min(rows.length - 1, Math.max(0, highlighted + delta));
+    paintHighlight();
+  }
+
+  /** `tab`: drill into the highlighted session's action page. No effect on any
+   *  other kind, and none on the page itself, which has no session rows. */
+  function drillIn(): void {
+    const candidate = rows[highlighted]?.candidate;
+    if (page || candidate?.kind !== "session") return;
+    page = candidate.session;
+    stashed = input.value;
+    input.value = "";
+    render();
+  }
+
+  /** Escape, or backspace at an empty query: back to the result list with the
+   *  query the drill-in was made from. */
+  function leavePage(): void {
+    page = null;
+    input.value = stashed;
+    stashed = "";
+    render();
+  }
+
+  function runAction(action: SessionAction, session: Session): void {
+    close();
+    switch (action.id) {
+      case "kill":
+        killSession(session);
+        return;
+      case "rename":
+        renameSession(session);
+        return;
+      case "spawn-similar":
+        spawnSimilar(session);
+        return;
+    }
+  }
+
+  function activate(index: number): void {
+    const result = rows[index];
+    if (!result) return;
+    const candidate = result.candidate;
+    if (isActionCandidate(candidate)) {
+      // The page cannot be up without a session to act on.
+      if (page) runAction(candidate.action, page);
+      return;
+    }
+    close();
+    switch (candidate.kind) {
+      case "session":
+        openSession(candidate.session.id);
+        return;
+      case "command":
+        candidate.command.run();
+        return;
+      case "directory":
+        spawnDirectory(candidate.path);
+        return;
+    }
+  }
+
+  function onKeydown(e: KeyboardEvent): void {
+    switch (e.key) {
+      case "Escape":
+        e.preventDefault();
+        // On an action page Escape is one level up, not the way out.
+        if (page) leavePage();
+        else close();
+        return;
+      case "Tab":
+        e.preventDefault();
+        drillIn();
+        return;
+      case "Backspace":
+        // Ordinary editing, except at an empty query on the action page.
+        if (page && input.value === "") {
+          e.preventDefault();
+          leavePage();
+        }
+        return;
+      case "Enter":
+        e.preventDefault();
+        activate(highlighted);
+        return;
+      case "ArrowDown":
+        e.preventDefault();
+        move(1);
+        return;
+      case "ArrowUp":
+        e.preventDefault();
+        move(-1);
+        return;
+      case "n":
+        if (e.ctrlKey) {
+          e.preventDefault();
+          move(1);
+        }
+        return;
+      case "p":
+        if (e.ctrlKey) {
+          e.preventDefault();
+          move(-1);
+        }
+        return;
+    }
+  }
+
+  function close(): void {
+    if (current?.el !== el) return;
+    current = null;
+    el.remove();
+    // Restoring focus is what makes the bar a view over the app rather than a
+    // place in it; a detached node cannot take it.
+    if (previouslyFocused?.isConnected) previouslyFocused.focus();
+  }
+
+  input.addEventListener("keydown", onKeydown);
+  input.addEventListener("input", render);
+  // A press on the scrim closes; one inside the panel is left alone.
+  el.addEventListener("mousedown", (ev) => {
+    if (!panel.contains(ev.target as Node)) close();
+  });
+
+  current = { el, dispose: close };
+  render();
+  input.focus();
+  return el;
+}

web/src/commands.test.ts

@@ -133,28 +133,31 @@ describe("CommandSet", () => {
     expect(run).toHaveBeenCalledTimes(2);
   });
 
-  it("keeps plain keys deaf inside a form field, and leader chords live from the pane", () => {
+  it("keeps plain keys deaf inside a form field, and chorded ones live", () => {
     const plain = vi.fn();
     const chorded = vi.fn();
     const set = new CommandSet(
-      defineCommands({ "spawn.open": plain, "focus.toggle": chorded }, DEFAULT_LEADER),
-      { leader: DEFAULT_LEADER },
+      defineCommands({ "spawn.open": plain, "focus.toggle": chorded }),
     );
     const input = el("<input>");
     expect(pressOn(set, input, "n")).toBe(false);
     expect(plain).not.toHaveBeenCalled();
-    // focus.toggle hangs off the leader (#166): a plain, unmodified Escape is
-    // left for the pane's shell/app instead.
-    const terminal = el('<textarea class="xterm-helper-textarea"></textarea>');
-    pressOn(set, terminal, "a", { ctrlKey: true });
-    expect(pressOn(set, terminal, "h")).toBe(true);
+    expect(pressOn(set, input, "H", { ctrlKey: true, shiftKey: true })).toBe(true);
     expect(chorded).toHaveBeenCalledTimes(1);
   });
 
-  it("leaves a plain Escape for the pane instead of binding it", () => {
-    const set = new CommandSet(defineCommands({ "spawn.open": vi.fn() }));
+  it("keeps pane commands live inside the terminal's textarea", () => {
+    const run = vi.fn();
+    const set = new CommandSet(defineCommands({ "pane.focusList": run }), {
+      preventDefault: false,
+    });
     const textarea = el('<textarea class="xterm-helper-textarea"></textarea>');
-    expect(pressOn(set, textarea, "Escape")).toBe(false);
+    const e = key("Escape");
+    Object.defineProperty(e, "target", { value: textarea });
+    expect(set.handle(e)).toBe(true);
+    expect(run).toHaveBeenCalledTimes(1);
+    // xterm is told to swallow by the return value, not by the browser default.
+    expect(e.defaultPrevented).toBe(false);
   });
 });
 
@@ -170,7 +173,6 @@ describe("the leader", () => {
     const byId = new Map(commandSpecs("ctrl-b").map((s) => [s.id, s]));
     expect(byId.get("pane.literalCtrlK")?.keys).toEqual(["ctrl-b ctrl-k"]);
     expect(byId.get("pane.literalLeader")?.keys).toEqual(["ctrl-b ctrl-b"]);
-    expect(byId.get("focus.toggle")?.keys).toEqual(["ctrl-b h"]);
     // Commands that do not hang off the leader are untouched.
     expect(byId.get("bar.open")?.keys).toEqual(["ctrl-k"]);
   });