feat(maestro): register dormant sessions on recovery

A host reboot kills the tmux server, so `SessionManager::recover` iterated an empty list and every session vanished from the API while its sidecar sat untouched on disk. A second recovery pass now reads the sidecars tmux had nothing to adopt and registers each as `SessionStatus::Dormant` — a record of what was running, with no pane and no PTY bridge behind it. `SessionStatus` deserializes leniently now, like `ActivityState`: an unknown spelling reads as `Dead` rather than failing the whole `Session`. Refs #162 Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-04 08:22:52 +01:00
292 changed files with 13519 additions and 37427 deletions
@@ -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
@@ -15,6 +15,3 @@ worktrees/

 # `nix run .#dev` scratch state (tmux socket)
 /.dev/
-
-# Per-machine Claude Code tool permissions
-.claude/settings.local.json
@@ -92,12 +92,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
@@ -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"
@@ -1,11 +0,0 @@
-*.iml
-.gradle/
-/local.properties
-/.idea/
-.DS_Store
-/build/
-/captures/
-.externalNativeBuild/
-.cxx/
-*.apk
-*.aab
@@ -1,81 +0,0 @@
-plugins {
-    alias(libs.plugins.android.application)
-    alias(libs.plugins.kotlin.android)
-    alias(libs.plugins.kotlin.compose)
-    alias(libs.plugins.kotlin.serialization)
-}
-
-android {
-    namespace = "pt.naps.maestro"
-    compileSdk = 34
-
-    defaultConfig {
-        applicationId = "pt.naps.maestro"
-        minSdk = 26
-        targetSdk = 34
-        versionCode = 1
-        versionName = "0.1.0"
-
-        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
-    }
-
-    signingConfigs {
-        getByName("debug") {
-            storeFile = file("debug.keystore")
-            storePassword = "android"
-            keyAlias = "androiddebugkey"
-            keyPassword = "android"
-        }
-    }
-
-    buildTypes {
-        release {
-            isMinifyEnabled = false
-            proguardFiles(
-                getDefaultProguardFile("proguard-android-optimize.txt"),
-                "proguard-rules.pro",
-            )
-        }
-        debug {
-            signingConfig = signingConfigs.getByName("debug")
-        }
-    }
-
-    compileOptions {
-        sourceCompatibility = JavaVersion.VERSION_17
-        targetCompatibility = JavaVersion.VERSION_17
-    }
-
-    kotlinOptions {
-        jvmTarget = "17"
-    }
-
-    buildFeatures {
-        compose = true
-    }
-}
-
-dependencies {
-    implementation(libs.androidx.core.ktx)
-    implementation(libs.androidx.lifecycle.runtime.ktx)
-    implementation(libs.androidx.activity.compose)
-    implementation(platform(libs.androidx.compose.bom))
-    implementation(libs.androidx.ui)
-    implementation(libs.androidx.ui.graphics)
-    implementation(libs.androidx.ui.tooling.preview)
-    implementation(libs.androidx.material3)
-    implementation(libs.androidx.navigation.compose)
-    implementation(libs.okhttp)
-    implementation(libs.kotlinx.serialization.json)
-    implementation(libs.kotlinx.coroutines.android)
-
-    testImplementation(libs.junit)
-
-    androidTestImplementation(libs.androidx.test.ext.junit)
-    androidTestImplementation(libs.androidx.espresso.core)
-    androidTestImplementation(platform(libs.androidx.compose.bom))
-    androidTestImplementation(libs.androidx.ui.test.junit4)
-
-    debugImplementation(libs.androidx.ui.tooling)
-    debugImplementation(libs.androidx.ui.test.manifest)
-}
@@ -1,6 +0,0 @@
-# Add project specific ProGuard rules here.
-# You can control the set of applied configuration files using the
-# proguardFiles setting in build.gradle.kts.
-#
-# For more details, see
-#   http://developer.android.com/guide/developing/tools/proguard.html
@@ -1,19 +0,0 @@
-package pt.naps.maestro
-
-import androidx.compose.ui.test.junit4.createAndroidComposeRule
-import androidx.compose.ui.test.onNodeWithText
-import androidx.test.ext.junit.runners.AndroidJUnit4
-import org.junit.Rule
-import org.junit.Test
-import org.junit.runner.RunWith
-
-@RunWith(AndroidJUnit4::class)
-class MainActivityTest {
-    @get:Rule
-    val composeTestRule = createAndroidComposeRule<MainActivity>()
-
-    @Test
-    fun placeholderScreen_showsAppName() {
-        composeTestRule.onNodeWithText("Maestro").assertExists()
-    }
-}
@@ -1,24 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<manifest xmlns:android="http://schemas.android.com/apk/res/android">
-
-    <uses-permission android:name="android.permission.INTERNET" />
-
-    <application
-        android:allowBackup="true"
-        android:icon="@mipmap/ic_launcher"
-        android:label="@string/app_name"
-        android:roundIcon="@mipmap/ic_launcher"
-        android:supportsRtl="true"
-        android:theme="@style/Theme.Maestro">
-        <activity
-            android:name=".MainActivity"
-            android:exported="true"
-            android:theme="@style/Theme.Maestro">
-            <intent-filter>
-                <action android:name="android.intent.action.MAIN" />
-                <category android:name="android.intent.category.LAUNCHER" />
-            </intent-filter>
-        </activity>
-    </application>
-
-</manifest>
@@ -1,61 +0,0 @@
-package pt.naps.maestro
-
-import android.os.Bundle
-import androidx.activity.ComponentActivity
-import androidx.activity.compose.setContent
-import androidx.activity.enableEdgeToEdge
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.padding
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.Scaffold
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.tooling.preview.Preview
-import androidx.compose.ui.unit.dp
-import pt.naps.maestro.ui.theme.MaestroTheme
-
-class MainActivity : ComponentActivity() {
-    override fun onCreate(savedInstanceState: Bundle?) {
-        super.onCreate(savedInstanceState)
-        enableEdgeToEdge()
-        setContent {
-            MaestroTheme {
-                Scaffold(modifier = Modifier.fillMaxSize()) { innerPadding ->
-                    PlaceholderScreen(modifier = Modifier.padding(innerPadding))
-                }
-            }
-        }
-    }
-}
-
-@Composable
-fun PlaceholderScreen(modifier: Modifier = Modifier) {
-    Column(
-        modifier = modifier
-            .fillMaxSize()
-            .padding(24.dp),
-        verticalArrangement = Arrangement.Center,
-        horizontalAlignment = Alignment.CenterHorizontally,
-    ) {
-        Text(
-            text = "Maestro",
-            style = MaterialTheme.typography.bodyLarge,
-        )
-        Text(
-            text = stringResource(id = R.string.placeholder_message),
-        )
-    }
-}
-
-@Preview(showBackground = true)
-@Composable
-private fun PlaceholderScreenPreview() {
-    MaestroTheme {
-        PlaceholderScreen()
-    }
-}
@@ -1,21 +0,0 @@
-package pt.naps.maestro.api
-
-import pt.naps.maestro.data.InTheWay
-
-/** A `/api` failure with the daemon's own error envelope kept intact, so a
- * caller can branch on [code] and render [unsavedWork] — the kill guard —
- * rather than re-parsing [detail]. Mirrors the web client's
- * `ApiRequestError`. */
-class MaestroApiException(
-    val status: Int,
-    val code: String,
-    val detail: String,
-    val unsavedWork: InTheWay? = null,
-) : Exception(buildMessage(status, code, detail)) {
-    private companion object {
-        fun buildMessage(status: Int, code: String, detail: String): String {
-            val info = if (code.isNotEmpty()) "$code: $detail" else detail
-            return if (info.isNotEmpty()) "$status — $info" else "$status"
-        }
-    }
-}
@@ -1,252 +0,0 @@
-package pt.naps.maestro.api
-
-import kotlinx.coroutines.suspendCancellableCoroutine
-import kotlinx.serialization.decodeFromString
-import kotlinx.serialization.encodeToString
-import kotlinx.serialization.json.Json
-import kotlinx.serialization.json.JsonElement
-import okhttp3.Call
-import okhttp3.Callback
-import okhttp3.HttpUrl.Companion.toHttpUrl
-import okhttp3.MediaType.Companion.toMediaType
-import okhttp3.OkHttpClient
-import okhttp3.Request
-import okhttp3.RequestBody.Companion.toRequestBody
-import okhttp3.Response
-import pt.naps.maestro.data.ApiError
-import pt.naps.maestro.data.BranchInfo
-import pt.naps.maestro.data.CreateSessionRequest
-import pt.naps.maestro.data.DaemonInfo
-import pt.naps.maestro.data.DirListing
-import pt.naps.maestro.data.GitRoot
-import pt.naps.maestro.data.NameBatch
-import pt.naps.maestro.data.Project
-import pt.naps.maestro.data.RecentDirs
-import pt.naps.maestro.data.RenameSessionRequest
-import pt.naps.maestro.data.Session
-import pt.naps.maestro.data.SetFocusRequest
-import pt.naps.maestro.data.StructuredAttachmentResponse
-import pt.naps.maestro.data.StructuredApprovalDecision
-import pt.naps.maestro.data.StructuredConfigRequest
-import pt.naps.maestro.data.StructuredPromptRequest
-import pt.naps.maestro.data.Uuid
-import java.io.IOException
-import kotlin.coroutines.resume
-import kotlin.coroutines.resumeWithException
-
-private val JSON_MEDIA_TYPE = "application/json; charset=utf-8".toMediaType()
-private val OCTET_STREAM_MEDIA_TYPE = "application/octet-stream".toMediaType()
-
-/**
- * Typed client for the daemon's `/api` surface (REST half). Mirrors
- * `maestro_protocol::client::DaemonClient` / `web/src/api.ts`.
- *
- * There is no authentication layer: reaching the daemon's bind address is
- * the authorization, same trust model as tmux itself.
- */
-class MaestroClient(
-    private val baseUrl: String,
-    private val httpClient: OkHttpClient = OkHttpClient(),
-) {
-    private val json = Json {
-        ignoreUnknownKeys = true
-        isLenient = true
-    }
-
-    suspend fun listSessions(): List<Session> = get(Routes.SESSIONS)
-
-    suspend fun createSession(request: CreateSessionRequest): Session =
-        post(Routes.SESSIONS, request)
-
-    /** `PATCH /api/sessions/:id`: rename a live session. An empty [name]
-     * clears the custom one, so the card falls back to the command. */
-    suspend fun renameSession(id: Uuid, name: String): Session =
-        patch(Routes.session(id), RenameSessionRequest(name))
-
-    /** `DELETE /api/sessions/:id`. With [force], the daemon overrides the
-     * kill refusal over a worktree holding unsaved work and leaves that
-     * worktree on disk. */
-    suspend fun killSession(id: Uuid, force: Boolean = false) {
-        val query = if (force) listOf(Routes.FORCE_QUERY to "true") else emptyList()
-        executeNoContent(newRequest("DELETE", Routes.session(id), query = query))
-    }
-
-    /** `POST /api/sessions/:id/focus`: report whether this client's pane is
-     * the one currently showing [id] — not merely highlighted in a
-     * sidebar. */
-    suspend fun setSessionFocus(id: Uuid, focused: Boolean) {
-        executeNoContent(
-            newRequest(
-                "POST",
-                Routes.sessionFocus(id),
-                body = json.encodeToString(SetFocusRequest(focused)),
-            ),
-        )
-    }
-
-    /** `GET /api/dirs?path=`: one directory's immediate subdirectories.
-     * [path] may be empty, `~`, relative, or absolute — the daemon resolves
-     * it against its home dir. */
-    suspend fun listDir(path: String): DirListing =
-        get(Routes.DIRS, listOf(Routes.PATH_QUERY to path))
-
-    /** `GET /api/info`: identity + spawn presets of the connected daemon. */
-    suspend fun getDaemonInfo(): DaemonInfo = get(Routes.INFO)
-
-    /** `GET /api/recent-dirs`: recently-used working dirs, newest-first and
-     * deduped by dir. */
-    suspend fun recentDirs(): RecentDirs = get(Routes.RECENT_DIRS)
-
-    /** `GET /api/projects`: every discovered git repository/worktree,
-     * newest-activity-first. */
-    suspend fun listProjects(): List<Project> = get(Routes.PROJECTS)
-
-    /** `GET /api/gitroot?path=`: the enclosing git repo of [path]; absent
-     * when [path] isn't inside a repo. */
-    suspend fun gitRoot(path: String): GitRoot =
-        get(Routes.GITROOT, listOf(Routes.PATH_QUERY to path))
-
-    /** `GET /api/names?count=`: a batch of fresh session handles. */
-    suspend fun fetchNames(count: Int): NameBatch =
-        get(Routes.NAMES, listOf(Routes.COUNT_QUERY to count.toString()))
-
-    /** `GET /api/branches?path=`: one repository's local branches, with
-     * worktree occupancy. */
-    suspend fun listBranches(path: String): List<BranchInfo> =
-        get(Routes.BRANCHES, listOf(Routes.PATH_QUERY to path))
-
-    /** Send a prompt to a structured session's ACP turn. `409
-     * turn_in_flight` when one is already active. */
-    suspend fun sendStructuredPrompt(id: Uuid, prompt: String) {
-        executeNoContent(
-            newRequest(
-                "POST",
-                Routes.structuredPrompt(id),
-                body = json.encodeToString(StructuredPromptRequest(prompt)),
-            ),
-        )
-    }
-
-    /** Upload a file attachment for a structured session's next prompt. */
-    suspend fun uploadStructuredAttachment(
-        id: Uuid,
-        fileName: String,
-        contents: ByteArray,
-    ): StructuredAttachmentResponse {
-        val url = Routes.httpUrl(baseUrl, Routes.structuredAttachment(id)).toHttpUrl()
-            .newBuilder()
-            .addQueryParameter("name", fileName)
-            .build()
-        val request = Request.Builder()
-            .url(url)
-            .post(contents.toRequestBody(OCTET_STREAM_MEDIA_TYPE))
-            .build()
-        return decode(execute(request))
-    }
-
-    /** Cancel a structured session's active ACP turn. */
-    suspend fun cancelStructuredTurn(id: Uuid) {
-        executeNoContent(newRequest("POST", Routes.structuredCancel(id)))
-    }
-
-    /** Change one option advertised by a live ACP session. */
-    suspend fun setStructuredConfig(id: Uuid, configId: String, value: JsonElement) {
-        executeNoContent(
-            newRequest(
-                "POST",
-                Routes.structuredConfig(id),
-                body = json.encodeToString(StructuredConfigRequest(configId, value)),
-            ),
-        )
-    }
-
-    /** Answer a pending ACP permission request. Always resolves once the
-     * session itself is a live structured session — a nonce that is unknown
-     * or already consumed still answers success. */
-    suspend fun resolveStructuredApproval(
-        id: Uuid,
-        nonce: String,
-        decision: StructuredApprovalDecision,
-    ) {
-        executeNoContent(
-            newRequest(
-                "POST",
-                Routes.structuredApproval(id, nonce),
-                body = json.encodeToString(decision),
-            ),
-        )
-    }
-
-    // -- plumbing ------------------------------------------------------
-
-    private suspend inline fun <reified T> get(
-        path: String,
-        query: List<Pair<String, String>> = emptyList(),
-    ): T = decode(execute(newRequest("GET", path, query = query)))
-
-    private suspend inline fun <reified B, reified T> post(path: String, body: B): T =
-        decode(execute(newRequest("POST", path, body = json.encodeToString(body))))
-
-    private suspend inline fun <reified B, reified T> patch(path: String, body: B): T =
-        decode(execute(newRequest("PATCH", path, body = json.encodeToString(body))))
-
-    private fun newRequest(
-        method: String,
-        path: String,
-        query: List<Pair<String, String>> = emptyList(),
-        body: String? = null,
-    ): Request {
-        val urlBuilder = Routes.httpUrl(baseUrl, path).toHttpUrl().newBuilder()
-        for ((key, value) in query) urlBuilder.addQueryParameter(key, value)
-        // OkHttp refuses a null body on POST/PUT/PATCH even when the daemon
-        // expects none (e.g. the structured-turn cancel) — an empty body
-        // satisfies it without implying a JSON payload.
-        val requestBody = when {
-            body != null -> body.toRequestBody(JSON_MEDIA_TYPE)
-            method == "POST" || method == "PUT" || method == "PATCH" -> ByteArray(0).toRequestBody(null)
-            else -> null
-        }
-        return Request.Builder()
-            .url(urlBuilder.build())
-            .method(method, requestBody)
-            .build()
-    }
-
-    private suspend fun execute(request: Request): Response =
-        suspendCancellableCoroutine { cont ->
-            val call = httpClient.newCall(request)
-            cont.invokeOnCancellation { call.cancel() }
-            call.enqueue(
-                object : Callback {
-                    override fun onFailure(call: Call, e: IOException) {
-                        if (!cont.isCancelled) cont.resumeWithException(e)
-                    }
-
-                    override fun onResponse(call: Call, response: Response) {
-                        cont.resume(response)
-                    }
-                },
-            )
-        }
-
-    private suspend fun executeNoContent(request: Request) {
-        execute(request).use { if (!it.isSuccessful) throw toApiException(it) }
-    }
-
-    private inline fun <reified T> decode(response: Response): T =
-        response.use {
-            if (!it.isSuccessful) throw toApiException(it)
-            json.decodeFromString<T>(it.body?.string().orEmpty())
-        }
-
-    private fun toApiException(response: Response): MaestroApiException {
-        val text = response.body?.string().orEmpty()
-        val info = runCatching { json.decodeFromString<ApiError>(text) }.getOrNull()?.error
-        return MaestroApiException(
-            status = response.code,
-            code = info?.code ?: "",
-            detail = info?.message ?: text,
-            unsavedWork = info?.unsaved_work,
-        )
-    }
-}
@@ -1,175 +0,0 @@
-package pt.naps.maestro.api
-
-import kotlinx.coroutines.channels.Channel
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.receiveAsFlow
-import kotlinx.serialization.decodeFromString
-import kotlinx.serialization.encodeToString
-import kotlinx.serialization.json.Json
-import okhttp3.OkHttpClient
-import okhttp3.Request
-import okhttp3.Response
-import okhttp3.WebSocket
-import okhttp3.WebSocketListener
-import okio.ByteString
-import pt.naps.maestro.data.CatalogEvent
-import pt.naps.maestro.data.ClientControl
-import pt.naps.maestro.data.StructuredEvent
-import pt.naps.maestro.data.Uuid
-
-private val wsJson = Json {
-    ignoreUnknownKeys = true
-    isLenient = true
-}
-
-/** One frame received on `WS /api/attach/:id`: raw PTY bytes, or a decoded
- * [ClientControl] text message. */
-sealed class AttachFrame {
-    data class Pty(val bytes: ByteArray) : AttachFrame()
-    data class Control(val message: ClientControl) : AttachFrame()
-}
-
-/** A live `WS /api/attach/:id` connection. PTY bytes travel in binary frames
- * both directions; control messages ([ClientControl]) travel in text
- * frames. */
-class AttachConnection internal constructor(
-    private val socket: WebSocket,
-    val frames: Flow<AttachFrame>,
-) {
-    /** Type raw bytes into the session's pane, as if typed on an attached
-     * terminal. */
-    fun sendInput(bytes: ByteArray) {
-        socket.send(ByteString.of(*bytes))
-    }
-
-    fun resize(cols: Int, rows: Int) {
-        sendControl(ClientControl.Resize(cols, rows))
-    }
-
-    fun ping() {
-        sendControl(ClientControl.Ping)
-    }
-
-    private fun sendControl(message: ClientControl) {
-        socket.send(wsJson.encodeToString(message))
-    }
-
-    fun close() {
-        socket.close(1000, null)
-    }
-}
-
-/** A live `WS /api/structured/:id` connection: transcript/state snapshots
- * and live deltas for one structured session. */
-class StructuredConnection internal constructor(
-    private val socket: WebSocket,
-    val events: Flow<StructuredEvent>,
-) {
-    fun close() {
-        socket.close(1000, null)
-    }
-}
-
-/** A live `WS /api/events` connection: catalog snapshot + session deltas. */
-class EventsConnection internal constructor(
-    private val socket: WebSocket,
-    val events: Flow<CatalogEvent>,
-) {
-    fun close() {
-        socket.close(1000, null)
-    }
-}
-
-/**
- * WebSocket half of the daemon's `/api` surface. Mirrors the `*_url`
- * helpers in `crates/maestro-protocol/src/routes.rs`.
- *
- * Each `connect*` call opens the socket immediately and returns a handle
- * whose `Flow` starts buffering frames right away — a slow collector never
- * misses a frame, it only sees it later. Call `close()` on the returned
- * connection when done; there is no automatic reconnect.
- */
-class MaestroWebSocket(
-    private val baseUrl: String,
-    private val httpClient: OkHttpClient = OkHttpClient(),
-) {
-    /** `WS /api/events`: catalog snapshot + session deltas. */
-    fun connectEvents(): EventsConnection {
-        val channel = Channel<CatalogEvent>(Channel.BUFFERED)
-        val socket = open(
-            Routes.eventsWsUrl(baseUrl),
-            object : WebSocketListener() {
-                override fun onMessage(webSocket: WebSocket, text: String) {
-                    runCatching { wsJson.decodeFromString<CatalogEvent>(text) }
-                        .onSuccess { channel.trySend(it) }
-                }
-
-                override fun onFailure(webSocket: WebSocket, t: Throwable, response: Response?) {
-                    channel.close(t)
-                }
-
-                override fun onClosed(webSocket: WebSocket, code: Int, reason: String) {
-                    channel.close()
-                }
-            },
-        )
-        return EventsConnection(socket, channel.receiveAsFlow())
-    }
-
-    /** `WS /api/attach/:id`: raw PTY bytes both directions, control messages
-     * as text JSON. */
-    fun connectAttach(id: Uuid): AttachConnection {
-        val channel = Channel<AttachFrame>(Channel.BUFFERED)
-        val socket = open(
-            Routes.attachWsUrl(baseUrl, id),
-            object : WebSocketListener() {
-                override fun onMessage(webSocket: WebSocket, text: String) {
-                    runCatching { wsJson.decodeFromString<ClientControl>(text) }
-                        .onSuccess { channel.trySend(AttachFrame.Control(it)) }
-                }
-
-                override fun onMessage(webSocket: WebSocket, bytes: ByteString) {
-                    channel.trySend(AttachFrame.Pty(bytes.toByteArray()))
-                }
-
-                override fun onFailure(webSocket: WebSocket, t: Throwable, response: Response?) {
-                    channel.close(t)
-                }
-
-                override fun onClosed(webSocket: WebSocket, code: Int, reason: String) {
-                    channel.close()
-                }
-            },
-        )
-        return AttachConnection(socket, channel.receiveAsFlow())
-    }
-
-    /** `WS /api/structured/:id`: transcript/state snapshots and live deltas
-     * for one structured session. */
-    fun connectStructured(id: Uuid): StructuredConnection {
-        val channel = Channel<StructuredEvent>(Channel.BUFFERED)
-        val socket = open(
-            Routes.structuredWsUrl(baseUrl, id),
-            object : WebSocketListener() {
-                override fun onMessage(webSocket: WebSocket, text: String) {
-                    runCatching { wsJson.decodeFromString<StructuredEvent>(text) }
-                        .onSuccess { channel.trySend(it) }
-                }
-
-                override fun onFailure(webSocket: WebSocket, t: Throwable, response: Response?) {
-                    channel.close(t)
-                }
-
-                override fun onClosed(webSocket: WebSocket, code: Int, reason: String) {
-                    channel.close()
-                }
-            },
-        )
-        return StructuredConnection(socket, channel.receiveAsFlow())
-    }
-
-    private fun open(url: String, listener: WebSocketListener): WebSocket {
-        val request = Request.Builder().url(url).build()
-        return httpClient.newWebSocket(request, listener)
-    }
-}
@@ -1,84 +0,0 @@
-package pt.naps.maestro.api
-
-import pt.naps.maestro.data.Uuid
-
-/** The daemon's `/api` surface: paths, and the scheme swap needed to reach
- * the WebSocket endpoints. Mirrors `maestro-protocol::routes` /
- * `web/src/routes.ts`. */
-object Routes {
-    const val API_PREFIX = "/api"
-
-    const val SESSIONS = "/api/sessions"
-    const val INFO = "/api/info"
-    const val DIRS = "/api/dirs"
-    const val RECENT_DIRS = "/api/recent-dirs"
-    const val PROJECTS = "/api/projects"
-    const val GITROOT = "/api/gitroot"
-    const val NAMES = "/api/names"
-    const val BRANCHES = "/api/branches"
-    const val EVENTS = "/api/events"
-
-    /** Name of the query parameter [DIRS], [GITROOT] and [BRANCHES] take. */
-    const val PATH_QUERY = "path"
-
-    /** Name of the query parameter `DELETE /api/sessions/:id` takes:
-     * `force=true` overrides the kill refusal over a guarded worktree. */
-    const val FORCE_QUERY = "force"
-
-    /** Name of the query parameter [NAMES] takes. */
-    const val COUNT_QUERY = "count"
-
-    fun session(id: Uuid): String = "$SESSIONS/$id"
-
-    fun sessionFocus(id: Uuid): String = "${session(id)}/focus"
-
-    fun attach(id: Uuid): String = "$API_PREFIX/attach/$id"
-
-    /** `WS /api/structured/:id` — transcript/state snapshots and live
-     * deltas. */
-    fun structured(id: Uuid): String = "$API_PREFIX/structured/$id"
-
-    /** `POST /api/sessions/:id/structured/prompt` — send an ACP prompt. */
-    fun structuredPrompt(id: Uuid): String = "${session(id)}/structured/prompt"
-
-    fun structuredAttachment(id: Uuid): String = "${session(id)}/structured/attachments"
-
-    /** `POST /api/sessions/:id/structured/cancel` — cancel an ACP turn. */
-    fun structuredCancel(id: Uuid): String = "${session(id)}/structured/cancel"
-
-    /** `POST /api/sessions/:id/structured/config` — change an ACP session
-     * option. */
-    fun structuredConfig(id: Uuid): String = "${session(id)}/structured/config"
-
-    /** `POST /api/sessions/:id/structured/approvals/:nonce` — answer a
-     * permission request. */
-    fun structuredApproval(id: Uuid, nonce: String): String =
-        "${session(id)}/structured/approvals/$nonce"
-
-    /** Strip a trailing slash so `{base}{path}` never doubles up. */
-    fun normalizeBase(base: String): String = base.trimEnd('/')
-
-    /** Join a daemon base URL and one of this object's paths. */
-    fun httpUrl(base: String, path: String): String = "${normalizeBase(base)}$path"
-
-    /** Swap an HTTP base URL for its WebSocket equivalent: `http://` becomes
-     * `ws://`, `https://` becomes `wss://`; a base already `ws(s)://` passes
-     * through. */
-    fun wsBase(httpBase: String): String {
-        val base = normalizeBase(httpBase)
-        return when {
-            base.startsWith("https://") -> "wss://${base.removePrefix("https://")}"
-            base.startsWith("http://") -> "ws://${base.removePrefix("http://")}"
-            base.startsWith("wss://") || base.startsWith("ws://") -> base
-            else -> throw IllegalArgumentException(
-                "daemon url has no supported scheme (want http/https/ws/wss): $httpBase",
-            )
-        }
-    }
-
-    fun eventsWsUrl(base: String): String = "${wsBase(base)}$EVENTS"
-
-    fun attachWsUrl(base: String, id: Uuid): String = "${wsBase(base)}${attach(id)}"
-
-    fun structuredWsUrl(base: String, id: Uuid): String = "${wsBase(base)}${structured(id)}"
-}
@@ -1,43 +0,0 @@
-package pt.naps.maestro.data
-
-import kotlinx.serialization.KSerializer
-import kotlinx.serialization.Serializable
-import kotlinx.serialization.descriptors.PrimitiveKind
-import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
-import kotlinx.serialization.descriptors.SerialDescriptor
-import kotlinx.serialization.encoding.Decoder
-import kotlinx.serialization.encoding.Encoder
-
-/**
- * Session activity, orthogonal to [SessionStatus]. Mirrors
- * `maestro_protocol::ActivityState`.
- *
- * Deserializes leniently: an unknown variant from a newer daemon decodes as
- * [Idle] instead of failing the whole [Session].
- */
-@Serializable(with = ActivityStateSerializer::class)
-enum class ActivityState {
-    Active,
-    Idle,
-    AwaitingInput,
-    Error,
-    Starting,
-}
-
-object ActivityStateSerializer : KSerializer<ActivityState> {
-    override val descriptor: SerialDescriptor =
-        PrimitiveSerialDescriptor("ActivityState", PrimitiveKind.STRING)
-
-    override fun serialize(encoder: Encoder, value: ActivityState) {
-        encoder.encodeString(value.name)
-    }
-
-    override fun deserialize(decoder: Decoder): ActivityState =
-        when (decoder.decodeString()) {
-            "Active" -> ActivityState.Active
-            "AwaitingInput" -> ActivityState.AwaitingInput
-            "Error" -> ActivityState.Error
-            "Starting" -> ActivityState.Starting
-            else -> ActivityState.Idle
-        }
-}
@@ -1,19 +0,0 @@
-package pt.naps.maestro.data
-
-import kotlinx.serialization.Serializable
-
-/** Structured failure body inside an [ApiError] envelope. Mirrors
- * `maestro_protocol::ErrorInfo`. */
-@Serializable
-data class ErrorInfo(
-    val code: String,
-    val message: String,
-    /** Set only by the kill guard: what blocked an unforced
-     * `DELETE /api/sessions/:id`. */
-    val unsaved_work: InTheWay? = null,
-)
-
-/** The envelope every `/api` failure is wrapped in: `{"error": {...}}`.
- * Mirrors `maestro_protocol::ApiError`. */
-@Serializable
-data class ApiError(val error: ErrorInfo)
@@ -1,17 +0,0 @@
-package pt.naps.maestro.data
-
-import kotlinx.serialization.Serializable
-
-/** One local branch of a repository, from `GET /api/branches`. A client
- * disables the entry when [is_head] is set or [worktree] is present — git
- * refuses to check the same branch out in two worktrees at once. Mirrors
- * `maestro_protocol::BranchInfo`. */
-@Serializable
-data class BranchInfo(
-    /** Short branch name (`main`, `feature/foo`). */
-    val name: String,
-    /** Whether this branch is the main checkout's current HEAD. */
-    val is_head: Boolean,
-    /** Toplevel path of the linked worktree holding this branch, if any. */
-    val worktree: String? = null,
-)
@@ -1,37 +0,0 @@
-package pt.naps.maestro.data
-
-import kotlinx.serialization.SerialName
-import kotlinx.serialization.Serializable
-
-/**
- * Messages the daemon broadcasts to clients over `WS /api/events`. Mirrors
- * `maestro_protocol::CatalogEvent`; tagged by a `type` field.
- *
- * A subscriber receives a single [Snapshot] immediately on connect, then a
- * stream of deltas as sessions are created, updated, and killed. Skipped
- * events (broadcast channel lag) surface as [Lagged].
- */
-@Serializable
-sealed class CatalogEvent {
-    @Serializable
-    @SerialName("Snapshot")
-    data class Snapshot(val sessions: List<Session>) : CatalogEvent()
-
-    @Serializable
-    @SerialName("SessionAdded")
-    data class SessionAdded(val session: Session) : CatalogEvent()
-
-    @Serializable
-    @SerialName("SessionRemoved")
-    data class SessionRemoved(val id: Uuid) : CatalogEvent()
-
-    @Serializable
-    @SerialName("SessionUpdated")
-    data class SessionUpdated(val session: Session) : CatalogEvent()
-
-    /** Server-issued notification that the broadcast queue dropped frames.
-     * Clients should re-fetch a full snapshot. */
-    @Serializable
-    @SerialName("Lagged")
-    data class Lagged(val skipped: Long) : CatalogEvent()
-}
@@ -1,30 +0,0 @@
-package pt.naps.maestro.data
-
-import kotlinx.serialization.SerialName
-import kotlinx.serialization.Serializable
-
-/** Text-frame control messages on a `WS /api/attach/:id` connection. PTY
- * bytes travel in binary frames and are not modeled here. Mirrors
- * `maestro_protocol::ClientControl`; tagged by a `type` field. */
-@Serializable
-sealed class ClientControl {
-    @Serializable
-    @SerialName("Resize")
-    data class Resize(val cols: Int, val rows: Int) : ClientControl()
-
-    @Serializable
-    @SerialName("Ping")
-    object Ping : ClientControl()
-
-    @Serializable
-    @SerialName("Pong")
-    object Pong : ClientControl()
-
-    @Serializable
-    @SerialName("Error")
-    data class Error(
-        val code: String,
-        val message: String,
-        val unsaved_work: InTheWay? = null,
-    ) : ClientControl()
-}
@@ -1,41 +0,0 @@
-package pt.naps.maestro.data
-
-import kotlinx.serialization.Serializable
-
-/** `GET /api/info` — the daemon's identity plus its spawn presets. Mirrors
- * `maestro_protocol::DaemonInfo`. */
-@Serializable
-data class DaemonInfo(
-    val hostname: String = "",
-    /** The protocol version the daemon implements. */
-    val version: String = "",
-    /** Home dir of the user the daemon runs as; empty for older daemons. */
-    val home_dir: String = "",
-    val presets: List<SpawnPreset> = emptyList(),
-    val build: BuildInfo = BuildInfo(),
-    /** Identity of the daemon *process*, regenerated on every start — a
-     * changed value across a reconnect means the daemon restarted. */
-    val instance: String = "",
-    /** Canonical leader key the operator configured (`[tui].leader`), so a
-     * client binds the same chord the TUI does. Empty means "use your
-     * default". */
-    val leader: String = "",
-)
-
-/** A spawn-form command preset advertised by the daemon. */
-@Serializable
-data class SpawnPreset(
-    val id: String,
-    val label: String,
-    val command: String,
-    val auto_approve: Boolean = false,
-)
-
-/** Build provenance of the running daemon. Every field is empty when the
- * binary was built outside a git checkout. */
-@Serializable
-data class BuildInfo(
-    val commit: String = "",
-    val commit_date: String = "",
-    val dirty: Boolean = false,
-)
@@ -1,33 +0,0 @@
-package pt.naps.maestro.data
-
-import kotlinx.serialization.Serializable
-
-/** `GET /api/dirs?path=` — one directory's immediate subdirectories. Mirrors
- * `maestro_protocol::DirListing`. */
-@Serializable
-data class DirListing(
-    /** Resolved absolute directory that was listed (after ~/relative
-     * expansion). */
-    val path: String,
-    /** Immediate subdirectory names, sorted case-insensitively. */
-    val entries: List<String> = emptyList(),
-    /** True when the listing was capped server-side. */
-    val truncated: Boolean = false,
-)
-
-/** One deduplicated recent working dir for the spawn form's recents picker.
- * Mirrors `maestro_protocol::RecentDir`. */
-@Serializable
-data class RecentDir(
-    val cwd: String,
-    val last_command: String,
-    val last_used: IsoTimestamp,
-)
-
-/** `GET /api/recent-dirs` — the daemon's recent working dirs, newest-first
- * and deduped by `cwd`. */
-@Serializable
-data class RecentDirs(
-    val dirs: List<RecentDir> = emptyList(),
-    val truncated: Boolean = false,
-)
@@ -1,9 +0,0 @@
-package pt.naps.maestro.data
-
-import kotlinx.serialization.Serializable
-
-/** `GET /api/gitroot?path=` — the enclosing repo toplevel of a path, or
- * `null` when the path isn't inside a repo. Mirrors
- * `maestro_protocol::GitRoot`. */
-@Serializable
-data class GitRoot(val root: String? = null)
@@ -1,7 +0,0 @@
-package pt.naps.maestro.data
-
-/** A session id. Mirrors `uuid::Uuid` on the wire — a plain UUID string. */
-typealias Uuid = String
-
-/** An RFC 3339 timestamp, as the daemon serializes `chrono::DateTime<Utc>`. */
-typealias IsoTimestamp = String
@@ -1,17 +0,0 @@
-package pt.naps.maestro.data
-
-import kotlinx.serialization.Serializable
-
-/** What currently blocks an unforced kill of a session's worktree,
- * recomputed by the daemon on every read. Mirrors
- * `maestro_protocol::InTheWay`. */
-@Serializable
-data class InTheWay(
-    val uncommitted_files: Int = 0,
-    val untracked_files: Int = 0,
-    val unpushed_commits: Int = 0,
-    /** Lines added across the tracked changes, staged and unstaged together. */
-    val insertions: Int = 0,
-    /** Lines removed across the same tracked changes. */
-    val deletions: Int = 0,
-)
@@ -1,8 +0,0 @@
-package pt.naps.maestro.data
-
-import kotlinx.serialization.Serializable
-
-/** `GET /api/names?count=N` — a batch of fresh session handles. Mirrors
- * `maestro_protocol::NameBatch`. */
-@Serializable
-data class NameBatch(val names: List<String>)
@@ -1,40 +0,0 @@
-package pt.naps.maestro.data
-
-import kotlinx.serialization.KSerializer
-import kotlinx.serialization.Serializable
-import kotlinx.serialization.descriptors.PrimitiveKind
-import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
-import kotlinx.serialization.descriptors.SerialDescriptor
-import kotlinx.serialization.encoding.Decoder
-import kotlinx.serialization.encoding.Encoder
-
-/**
- * Where a session's stored name (`metadata["name"]`) came from. Mirrors
- * `maestro_protocol::NameSource`.
- *
- * Deserializes leniently: an unknown spelling decodes as [User], the settled
- * variant — a name wrongly painted as settled is only a missed dimming; one
- * wrongly painted as provisional invites overwriting a name a person chose.
- */
-@Serializable(with = NameSourceSerializer::class)
-enum class NameSource {
-    User,
-    Generated,
-    Haiku,
-}
-
-object NameSourceSerializer : KSerializer<NameSource> {
-    override val descriptor: SerialDescriptor =
-        PrimitiveSerialDescriptor("NameSource", PrimitiveKind.STRING)
-
-    override fun serialize(encoder: Encoder, value: NameSource) {
-        encoder.encodeString(value.name)
-    }
-
-    override fun deserialize(decoder: Decoder): NameSource =
-        when (decoder.decodeString()) {
-            "Generated" -> NameSource.Generated
-            "Haiku" -> NameSource.Haiku
-            else -> NameSource.User
-        }
-}
@@ -1,21 +0,0 @@
-package pt.naps.maestro.data
-
-import kotlinx.serialization.Serializable
-
-/** One discovered git repository (or linked worktree) for `GET
- * /api/projects`. Mirrors `maestro_protocol::Project`. */
-@Serializable
-data class Project(
-    /** Absolute path of the repository/worktree toplevel. */
-    val path: String,
-    /** Basename of [path]. */
-    val name: String,
-    val is_worktree: Boolean = false,
-    /** The main checkout this worktree belongs to; `null` on plain repos. */
-    val base_repo: String? = null,
-    /** Later of the repo's git HEAD mtime and the newest spawn-history use of
-     * any directory inside it; `null` when neither is known. */
-    val last_activity: IsoTimestamp? = null,
-    /** Command last spawned in this project, from spawn history. */
-    val last_command: String? = null,
-)
@@ -1,71 +0,0 @@
-package pt.naps.maestro.data
-
-import kotlinx.serialization.Serializable
-import kotlinx.serialization.json.JsonElement
-
-/** Default for [Session.last_activity_at] / [Session.activity_since] when an
- * older payload omits them — mirrors the daemon's Unix-epoch default. */
-const val EPOCH: IsoTimestamp = "1970-01-01T00:00:00Z"
-
-/** A live or recently-dead tmux session managed by the daemon. Mirrors
- * `maestro_protocol::Session`. */
-@Serializable
-data class Session(
-    val id: Uuid,
-    val cwd: String,
-    val command: String,
-    val env: Map<String, String> = emptyMap(),
-    val metadata: Map<String, JsonElement> = emptyMap(),
-    /** The worktree this session owns, when it was spawned with one. */
-    val worktree: SessionWorktree? = null,
-    val status: SessionStatus,
-    val created_at: IsoTimestamp,
-    /** Current foreground command in the pane (e.g. `claude`, `bash`), as the
-     * daemon's activity watcher observed it. `null` until observed. */
-    val foreground: String? = null,
-    /** Inferred activity dimension, orthogonal to [status]. */
-    val activity: ActivityState = ActivityState.Idle,
-    /** Short human string an agent reported alongside its activity — e.g. why
-     * it is in [ActivityState.Error]. `null` unless an agent reported one. */
-    val activity_detail: String? = null,
-    val last_activity_at: IsoTimestamp = EPOCH,
-    val activity_since: IsoTimestamp = EPOCH,
-    /** The pane's *current* working directory, distinct from [cwd] (the spawn
-     * dir). `null` until first observed. */
-    val current_cwd: String? = null,
-    /** What currently blocks an unforced kill of this session, as the
-     * daemon's watcher last probed it. `null` while clear or not yet probed. */
-    val blocked_work: InTheWay? = null,
-    /** When this session last became the pane a client was showing. `null`
-     * until the session has been focused at least once. */
-    val last_focused_at: IsoTimestamp? = null,
-    /** Terminal (PTY bytes) or structured (ACP rows). Fixed at spawn and
-     * immutable for the session's life. */
-    val view: SessionView = SessionView.Terminal,
-    /** The ACP session id the selected provider adapter returned from
-     * `session/new`. Only a [SessionView.Structured] session whose handshake
-     * succeeded has one. */
-    val acp_session_id: String? = null,
-    /** When `true`, the daemon auto-approves every ACP permission request for
-     * this session instead of surfacing them to the client. */
-    val auto_approve: Boolean = false,
-    /** Prompts queued on the daemon while a turn was in flight or the adapter
-     * was still booting. */
-    val queued_prompts: List<String> = emptyList(),
-)
-
-@Serializable
-enum class SessionStatus { Running, Dead }
-
-/** A session's process shape: mirrors `maestro_protocol::SessionView`.
- * `Terminal` is the default. */
-@Serializable
-enum class SessionView { Terminal, Structured }
-
-/** A session's daemon-created worktree. `base_repo` is the repository's main
- * checkout, which is what the session tree groups by. */
-@Serializable
-data class SessionWorktree(
-    val path: String,
-    val base_repo: String,
-)
@@ -1,43 +0,0 @@
-package pt.naps.maestro.data
-
-import kotlinx.serialization.Serializable
-import kotlinx.serialization.json.JsonElement
-
-/** `POST /api/sessions` body. Mirrors
- * `maestro_protocol::CreateSessionRequest`. */
-@Serializable
-data class CreateSessionRequest(
-    val cwd: String,
-    val command: String,
-    val env: Map<String, String> = emptyMap(),
-    val metadata: Map<String, JsonElement> = emptyMap(),
-    val worktree: WorktreeSpec? = null,
-    /** The process shape to spawn. Defaults to a `Terminal` session. */
-    val view: SessionView = SessionView.Terminal,
-    /** When `true`, the daemon auto-approves every ACP permission request for
-     * this structured session. */
-    val auto_approve: Boolean = false,
-)
-
-/** Optional worktree request attached to a [CreateSessionRequest]. Mirrors
- * `maestro_protocol::WorktreeSpec`. */
-@Serializable
-data class WorktreeSpec(
-    val base_repo: String,
-    val branch: String,
-    /** When `false`, [branch] already exists and is checked out as-is.
-     * Defaults to `true` (create a new branch). */
-    val create_branch: Boolean = true,
-)
-
-/** `PATCH /api/sessions/:id` body: rename a live session. An empty [name]
- * clears the custom one, so the card falls back to the command. Mirrors
- * `maestro_protocol::RenameSessionRequest`. */
-@Serializable
-data class RenameSessionRequest(val name: String)
-
-/** `POST /api/sessions/:id/focus` body: a client reports whether its pane is
- * the one currently showing this session. Mirrors
- * `maestro_protocol::SetFocusRequest`. */
-@Serializable
-data class SetFocusRequest(val focused: Boolean)
@@ -1,136 +0,0 @@
-package pt.naps.maestro.data
-
-import kotlinx.serialization.SerialName
-import kotlinx.serialization.Serializable
-import kotlinx.serialization.json.JsonElement
-
-/** The semantic shape of a [TranscriptRow]. Mirrors
- * `maestro_protocol::TranscriptRowKind`, snake_case on the wire. */
-@Serializable
-enum class TranscriptRowKind {
-    @SerialName("user") User,
-    @SerialName("agent_text") AgentText,
-    @SerialName("agent_thought") AgentThought,
-    @SerialName("tool_call") ToolCall,
-    @SerialName("tool_diff") ToolDiff,
-    @SerialName("approval") Approval,
-    @SerialName("plan") Plan,
-    @SerialName("notice") Notice,
-}
-
-/** One client-neutral item in a structured session transcript. [data]
- * preserves the ACP payload verbatim without committing to an ACP
- * dependency. Mirrors `maestro_protocol::TranscriptRow`. */
-@Serializable
-data class TranscriptRow(
-    /** Stable within one session, so later deltas can address this row. */
-    val id: String,
-    val kind: TranscriptRowKind,
-    val data: JsonElement,
-)
-
-/** The complete transcript at a durable event-log position — a structured
- * session's first `WS /api/structured/:id` message. Mirrors
- * `maestro_protocol::TranscriptSnapshot`. */
-@Serializable
-data class TranscriptSnapshot(
-    val cursor: Long,
-    val rows: List<TranscriptRow> = emptyList(),
-)
-
-/** A change to one transcript row, addressed by [id]. Mirrors
- * `maestro_protocol::TranscriptDelta`; tagged by a snake_case `type` field. */
-@Serializable
-sealed class TranscriptDelta {
-    @Serializable
-    @SerialName("append")
-    data class Append(val row: TranscriptRow) : TranscriptDelta()
-
-    @Serializable
-    @SerialName("patch")
-    data class Patch(val row: TranscriptRow) : TranscriptDelta()
-
-    @Serializable
-    @SerialName("remove")
-    data class Remove(val id: String) : TranscriptDelta()
-}
-
-/** Per-turn indicators derived from the ACP stream — read verbatim, never
- * re-derived client-side. Mirrors `maestro_protocol::TurnState`. */
-@Serializable
-data class TurnState(
-    val responding: Boolean = false,
-    val thinking: Boolean = false,
-    val active_tool_calls: List<String> = emptyList(),
-    /** Wall-clock start of the active prompt, so a reconnecting client keeps
-     * one continuous elapsed-time display instead of restarting at zero. */
-    val started_at: IsoTimestamp? = null,
-    val started_context_tokens: Long? = null,
-)
-
-/**
- * A whole-session view derived from ACP notifications. Mirrors
- * `maestro_protocol::ReducedState`.
- *
- * [pending_approval], [plan], [usage], [context] and [config_options] carry
- * opaque ACP JSON — their shape is ACP's, not covered by this crate's own
- * compatibility guarantee, so they are kept as [JsonElement] rather than
- * modeled strongly.
- */
-@Serializable
-data class ReducedState(
-    val turn: TurnState = TurnState(),
-    val pending_approval: JsonElement? = null,
-    val plan: JsonElement? = null,
-    val usage: JsonElement? = null,
-    val context: JsonElement? = null,
-    val model: String? = null,
-    val mode: String? = null,
-    val config_options: JsonElement? = null,
-    /** Prompts queued on the daemon while a turn is in flight. */
-    val queued_prompts: List<String> = emptyList(),
-)
-
-/** Server messages on `WS /api/structured/:id`. Mirrors
- * `maestro_protocol::StructuredEvent`; tagged by a snake_case `type` field. */
-@Serializable
-sealed class StructuredEvent {
-    @Serializable
-    @SerialName("transcript_snapshot")
-    data class TranscriptSnapshotEvent(val snapshot: TranscriptSnapshot) : StructuredEvent()
-
-    @Serializable
-    @SerialName("reduced_state")
-    data class ReducedStateEvent(val state: ReducedState) : StructuredEvent()
-
-    @Serializable
-    @SerialName("projection_update")
-    data class ProjectionUpdate(
-        val transcript: TranscriptDelta? = null,
-        val state: ReducedState,
-    ) : StructuredEvent()
-}
-
-/** `POST /api/sessions/:id/structured/prompt` body. */
-@Serializable
-data class StructuredPromptRequest(val prompt: String)
-
-/** `POST /api/sessions/:id/structured/config` body: change one option
- * advertised by a live ACP session. */
-@Serializable
-data class StructuredConfigRequest(val config_id: String, val value: JsonElement)
-
-/** Operator decision for a pending ACP permission request
- * (`POST /api/sessions/:id/structured/approvals/:nonce` body) — a bare JSON
- * string on the wire, not `{decision: ...}`. Mirrors
- * `maestro_protocol::StructuredApprovalDecision`. */
-@Serializable
-enum class StructuredApprovalDecision {
-    @SerialName("allow_once") AllowOnce,
-    @SerialName("allow_for_session") AllowForSession,
-    @SerialName("deny") Deny,
-}
-
-/** Response of `POST /api/sessions/:id/structured/attachments`. */
-@Serializable
-data class StructuredAttachmentResponse(val path: String)
@@ -1,11 +0,0 @@
-package pt.naps.maestro.ui.theme
-
-import androidx.compose.ui.graphics.Color
-
-val Purple80 = Color(0xFFD0BCFF)
-val PurpleGrey80 = Color(0xFFCCC2DC)
-val Pink80 = Color(0xFFEFB8C8)
-
-val Purple40 = Color(0xFF6650a4)
-val PurpleGrey40 = Color(0xFF625b71)
-val Pink40 = Color(0xFF7D5260)
@@ -1,46 +0,0 @@
-package pt.naps.maestro.ui.theme
-
-import android.os.Build
-import androidx.compose.foundation.isSystemInDarkTheme
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.darkColorScheme
-import androidx.compose.material3.dynamicDarkColorScheme
-import androidx.compose.material3.dynamicLightColorScheme
-import androidx.compose.material3.lightColorScheme
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.platform.LocalContext
-
-private val DarkColorScheme = darkColorScheme(
-    primary = Purple80,
-    secondary = PurpleGrey80,
-    tertiary = Pink80,
-)
-
-private val LightColorScheme = lightColorScheme(
-    primary = Purple40,
-    secondary = PurpleGrey40,
-    tertiary = Pink40,
-)
-
-@Composable
-fun MaestroTheme(
-    darkTheme: Boolean = true,
-    dynamicColor: Boolean = false,
-    content: @Composable () -> Unit,
-) {
-    val useDarkTheme = darkTheme || isSystemInDarkTheme()
-    val colorScheme = when {
-        dynamicColor && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S -> {
-            val context = LocalContext.current
-            if (useDarkTheme) dynamicDarkColorScheme(context) else dynamicLightColorScheme(context)
-        }
-        useDarkTheme -> DarkColorScheme
-        else -> LightColorScheme
-    }
-
-    MaterialTheme(
-        colorScheme = colorScheme,
-        typography = Typography,
-        content = content,
-    )
-}
@@ -1,17 +0,0 @@
-package pt.naps.maestro.ui.theme
-
-import androidx.compose.material3.Typography
-import androidx.compose.ui.text.TextStyle
-import androidx.compose.ui.text.font.FontFamily
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.unit.sp
-
-val Typography = Typography(
-    bodyLarge = TextStyle(
-        fontFamily = FontFamily.Default,
-        fontWeight = FontWeight.Normal,
-        fontSize = 16.sp,
-        lineHeight = 24.sp,
-        letterSpacing = 0.5.sp,
-    ),
-)
@@ -1,10 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<vector xmlns:android="http://schemas.android.com/apk/res/android"
-    android:width="108dp"
-    android:height="108dp"
-    android:viewportWidth="108"
-    android:viewportHeight="108">
-    <path
-        android:fillColor="#1B1B1B"
-        android:pathData="M0,0h108v108h-108z" />
-</vector>
@@ -1,10 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<vector xmlns:android="http://schemas.android.com/apk/res/android"
-    android:width="108dp"
-    android:height="108dp"
-    android:viewportWidth="108"
-    android:viewportHeight="108">
-    <path
-        android:fillColor="#D0BCFF"
-        android:pathData="M54,24L74,84L64,84L54,52L44,84L34,84Z" />
-</vector>
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
-    <background android:drawable="@drawable/ic_launcher_background" />
-    <foreground android:drawable="@drawable/ic_launcher_foreground" />
-</adaptive-icon>
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
-    <background android:drawable="@drawable/ic_launcher_background" />
-    <foreground android:drawable="@drawable/ic_launcher_foreground" />
-</adaptive-icon>
@@ -1,4 +0,0 @@
-<resources>
-    <string name="app_name">Maestro</string>
-    <string name="placeholder_message">Maestro is not connected to a daemon yet.</string>
-</resources>
@@ -1,6 +0,0 @@
-<resources xmlns:tools="http://schemas.android.com/tools">
-    <style name="Theme.Maestro" parent="android:Theme.Material.NoActionBar">
-        <item name="android:statusBarColor" tools:targetApi="21">@android:color/black</item>
-        <item name="android:windowBackground">@android:color/black</item>
-    </style>
-</resources>
@@ -1,11 +0,0 @@
-package pt.naps.maestro
-
-import org.junit.Assert.assertEquals
-import org.junit.Test
-
-class ExampleUnitTest {
-    @Test
-    fun addition_isCorrect() {
-        assertEquals(4, 2 + 2)
-    }
-}
@@ -1,114 +0,0 @@
-package pt.naps.maestro.data
-
-import kotlinx.serialization.decodeFromString
-import kotlinx.serialization.encodeToString
-import kotlinx.serialization.json.Json
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertNull
-import org.junit.Assert.assertTrue
-import org.junit.Test
-
-/** Wire-format checks against fixtures mirrored from
- * `crates/maestro-protocol/src/lib.rs`'s own test suite, so a Kotlin type
- * that drifts from the Rust source of truth fails here first. */
-class WireSerializationTest {
-    private val json = Json { ignoreUnknownKeys = true; isLenient = true }
-
-    private fun legacySessionJson(extra: String = "") = """
-        {"id":"00000000-0000-0000-0000-000000000001","cwd":"/tmp","command":"bash",
-         "status":"Running","created_at":"2026-05-24T12:00:00Z"$extra}
-    """.trimIndent()
-
-    @Test
-    fun `legacy session payload defaults new fields`() {
-        val s = json.decodeFromString<Session>(legacySessionJson())
-        assertEquals(ActivityState.Idle, s.activity)
-        assertEquals(SessionView.Terminal, s.view)
-        assertNull(s.foreground)
-        assertNull(s.blocked_work)
-        assertEquals(EPOCH, s.last_activity_at)
-    }
-
-    @Test
-    fun `unknown activity state degrades to Idle`() {
-        val s = json.decodeFromString<Session>(legacySessionJson(""","activity":"QuantumEntangled""""))
-        assertEquals(ActivityState.Idle, s.activity)
-    }
-
-    @Test
-    fun `unknown name source degrades to User`() {
-        assertEquals(NameSource.User, json.decodeFromString<NameSource>("\"Rolled\""))
-        assertEquals(NameSource.Haiku, json.decodeFromString<NameSource>("\"Haiku\""))
-    }
-
-    @Test
-    fun `catalog event tags by type`() {
-        assertEquals(
-            """{"type":"Lagged","skipped":3}""",
-            json.encodeToString<CatalogEvent>(CatalogEvent.Lagged(3)),
-        )
-        val removed = CatalogEvent.SessionRemoved("00000000-0000-0000-0000-000000000001")
-        assertEquals(removed, json.decodeFromString<CatalogEvent>(json.encodeToString<CatalogEvent>(removed)))
-    }
-
-    @Test
-    fun `client control tags by type`() {
-        assertEquals(
-            """{"type":"Resize","cols":120,"rows":40}""",
-            json.encodeToString<ClientControl>(ClientControl.Resize(120, 40)),
-        )
-        assertEquals(ClientControl.Ping, json.decodeFromString<ClientControl>("""{"type":"Ping"}"""))
-    }
-
-    @Test
-    fun `structured approval decision is a bare string`() {
-        assertEquals(
-            StructuredApprovalDecision.AllowOnce,
-            json.decodeFromString<StructuredApprovalDecision>("\"allow_once\""),
-        )
-        assertEquals(
-            "\"allow_for_session\"",
-            json.encodeToString(StructuredApprovalDecision.AllowForSession),
-        )
-    }
-
-    @Test
-    fun `structured event tags snake_case`() {
-        val event = json.decodeFromString<StructuredEvent>(
-            """{"type":"transcript_snapshot","snapshot":{"cursor":7,"rows":[]}}""",
-        )
-        assertTrue(event is StructuredEvent.TranscriptSnapshotEvent)
-        assertEquals(7L, (event as StructuredEvent.TranscriptSnapshotEvent).snapshot.cursor)
-    }
-
-    @Test
-    fun `transcript delta tags snake_case and round trips`() {
-        val row = TranscriptRow(
-            id = "tool:read-1",
-            kind = TranscriptRowKind.ToolCall,
-            data = json.parseToJsonElement("""{"name":"vendor.read"}"""),
-        )
-        val patch = TranscriptDelta.Patch(row)
-        val encoded = json.encodeToString<TranscriptDelta>(patch)
-        assertTrue(encoded.startsWith("""{"type":"patch","row":"""))
-        assertEquals(patch, json.decodeFromString<TranscriptDelta>(encoded))
-        assertEquals("\"agent_thought\"", json.encodeToString(TranscriptRowKind.AgentThought))
-    }
-
-    @Test
-    fun `rename request encodes plainly`() {
-        assertEquals(
-            """{"name":"amber-falcon"}""",
-            json.encodeToString(RenameSessionRequest("amber-falcon")),
-        )
-    }
-
-    @Test
-    fun `api error decodes nested unsaved work with defaults`() {
-        val apiError = json.decodeFromString<ApiError>(
-            """{"error":{"code":"unsaved_work","message":"nope","unsaved_work":{"uncommitted_files":3}}}""",
-        )
-        assertEquals(3, apiError.error.unsaved_work?.uncommitted_files)
-        assertEquals(0, apiError.error.unsaved_work?.unpushed_commits)
-    }
-}
@@ -1,6 +0,0 @@
-plugins {
-    alias(libs.plugins.android.application) apply false
-    alias(libs.plugins.kotlin.android) apply false
-    alias(libs.plugins.kotlin.compose) apply false
-    alias(libs.plugins.kotlin.serialization) apply false
-}
@@ -1,4 +0,0 @@
-org.gradle.jvmargs=-Xmx2048m -Dfile.encoding=UTF-8
-org.gradle.parallel=true
-android.useAndroidX=true
-kotlin.code.style=official
@@ -1,37 +0,0 @@
-[versions]
-agp = "8.5.2"
-kotlin = "2.0.21"
-coreKtx = "1.13.1"
-lifecycleRuntimeKtx = "2.8.6"
-activityCompose = "1.9.2"
-composeBom = "2024.09.03"
-navigationCompose = "2.8.2"
-okhttp = "4.12.0"
-kotlinxSerializationJson = "1.7.3"
-kotlinxCoroutines = "1.9.0"
-
-[libraries]
-androidx-core-ktx = { group = "androidx.core", name = "core-ktx", version.ref = "coreKtx" }
-androidx-lifecycle-runtime-ktx = { group = "androidx.lifecycle", name = "lifecycle-runtime-ktx", version.ref = "lifecycleRuntimeKtx" }
-androidx-activity-compose = { group = "androidx.activity", name = "activity-compose", version.ref = "activityCompose" }
-androidx-compose-bom = { group = "androidx.compose", name = "compose-bom", version.ref = "composeBom" }
-androidx-ui = { group = "androidx.compose.ui", name = "ui" }
-androidx-ui-graphics = { group = "androidx.compose.ui", name = "ui-graphics" }
-androidx-ui-tooling = { group = "androidx.compose.ui", name = "ui-tooling" }
-androidx-ui-tooling-preview = { group = "androidx.compose.ui", name = "ui-tooling-preview" }
-androidx-ui-test-manifest = { group = "androidx.compose.ui", name = "ui-test-manifest" }
-androidx-ui-test-junit4 = { group = "androidx.compose.ui", name = "ui-test-junit4" }
-androidx-material3 = { group = "androidx.compose.material3", name = "material3" }
-androidx-navigation-compose = { group = "androidx.navigation", name = "navigation-compose", version.ref = "navigationCompose" }
-okhttp = { group = "com.squareup.okhttp3", name = "okhttp", version.ref = "okhttp" }
-kotlinx-serialization-json = { group = "org.jetbrains.kotlinx", name = "kotlinx-serialization-json", version.ref = "kotlinxSerializationJson" }
-kotlinx-coroutines-android = { group = "org.jetbrains.kotlinx", name = "kotlinx-coroutines-android", version.ref = "kotlinxCoroutines" }
-junit = { group = "junit", name = "junit", version = "4.13.2" }
-androidx-test-ext-junit = { group = "androidx.test.ext", name = "junit", version = "1.2.1" }
-androidx-espresso-core = { group = "androidx.test.espresso", name = "espresso-core", version = "3.6.1" }
-
-[plugins]
-android-application = { id = "com.android.application", version.ref = "agp" }
-kotlin-android = { id = "org.jetbrains.kotlin.android", version.ref = "kotlin" }
-kotlin-compose = { id = "org.jetbrains.kotlin.plugin.compose", version.ref = "kotlin" }
-kotlin-serialization = { id = "org.jetbrains.kotlin.plugin.serialization", version.ref = "kotlin" }
@@ -1,7 +0,0 @@
-distributionBase=GRADLE_USER_HOME
-distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.7-bin.zip
-networkTimeout=10000
-validateDistributionUrl=true
-zipStoreBase=GRADLE_USER_HOME
-zipStorePath=wrapper/dists
@@ -1,237 +0,0 @@
-#!/bin/sh
-
-#
-# Copyright © 2015-2021 the original authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      https://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-##############################################################################
-#
-#   Gradle start up script for POSIX generated by Gradle.
-#
-#   Important for running:
-#
-#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
-#       noncompliant, but you have some other compliant shell such as ksh or
-#       bash, then to run this script, type that shell name before the whole
-#       command line, like:
-#
-#           ksh Gradle
-#
-#       Busybox and similar reduced shells will NOT work, because this script
-#       requires all of these POSIX shell features:
-#         * functions;
-#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
-#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
-#         * compound commands having a testable exit status, especially «case»;
-#         * various built-in commands including «command», «set», and «ulimit».
-#
-#   Important for patching:
-#
-#   (2) This script targets any POSIX shell, so it avoids extensions provided
-#       by Bash, Ksh, etc; in particular arrays are avoided.
-#
-#       The "traditional" practice of packing multiple parameters into a
-#       space-separated string is a well documented source of bugs and security
-#       issues, so this is (mostly) avoided, by progressively accumulating
-#       options in "$@", and eventually passing that to Java.
-#
-#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
-#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
-#       see the in-line comments for details.
-#
-#       There are tweaks for specific operating systems such as AIX, CygWin,
-#       Darwin, MinGW, and NonStop.
-#
-#   (3) This script is generated via the Gradle "wrapper" task
-#       (see https://docs.gradle.org/current/userguide/gradle_wrapper.html)
-#       within the Gradle project.
-#
-#       You can find Gradle at https://github.com/gradle/gradle/.
-#
-##############################################################################
-
-# Attempt to set APP_HOME
-
-# Resolve links: $0 may be a link
-app_path=$0
-
-# Need this for daisy-chained symlinks.
-while
-    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
-    [ -h "$app_path" ]
-do
-    ls=$( ls -ld "$app_path" )
-    link=${ls#*' -> '}
-    case $link in             #(
-      /*)   app_path=$link ;; #(
-      *)    app_path=$APP_HOME$link ;;
-    esac
-done
-
-# This is normally unused
-# shellcheck disable=SC2034
-APP_BASE_NAME=${0##*/}
-APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
-
-# Use the maximum available, or set MAX_FD != -1 to use that value.
-MAX_FD=maximum
-
-warn () {
-    echo "$*"
-} >&2
-
-die () {
-    echo
-    echo "$*"
-    echo
-    exit 1
-} >&2
-
-# OS specific support (must be 'true' or 'false').
-cygwin=false
-msys=false
-darwin=false
-nonstop=false
-case "$( uname )" in                #(
-  CYGWIN* )         cygwin=true  ;; #(
-  Darwin* )         darwin=true  ;; #(
-  MSYS* | MINGW* )  msys=true    ;; #(
-  NONSTOP* )        nonstop=true ;;
-esac
-
-CLASSPATH="$APP_HOME/gradle/wrapper/gradle-wrapper.jar"
-
-
-# Determine the Java command to use to start the JVM.
-if [ -n "$JAVA_HOME" ] ; then
-    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
-        # IBM's JDK on AIX uses strange locations for the executables
-        JAVACMD=$JAVA_HOME/jre/sh/java
-    else
-        JAVACMD=$JAVA_HOME/bin/java
-    fi
-    if [ ! -x "$JAVACMD" ] ; then
-        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
-
-Please set the JAVA_HOME variable in your environment to match the
-location of your Java installation."
-    fi
-else
-    JAVACMD=java
-    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-
-Please set the JAVA_HOME variable in your environment to match the
-location of your Java installation."
-fi
-
-# Increase the maximum file descriptors if we can.
-if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
-    case $MAX_FD in #(
-      max*)
-        MAX_FD=$( ulimit -H -n ) ||
-            warn "Could not query maximum file descriptor limit"
-    esac
-    case $MAX_FD in  #(
-      '' | soft) :;; #(
-      *)
-        ulimit -n "$MAX_FD" ||
-            warn "Could not set maximum file descriptor limit to $MAX_FD"
-    esac
-fi
-
-# Collect all arguments for the java command, stacking in reverse order:
-#   * args from the command line
-#   * the main class name
-#   * -classpath
-#   * -D...appname settings
-#   * --module-path (only if needed)
-#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
-
-# For Cygwin or MSYS, switch paths to Windows format before running java
-if "$cygwin" || "$msys" ; then
-    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
-    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
-
-    JAVACMD=$( cygpath --unix "$JAVACMD" )
-
-    # Now convert the arguments - kludge to limit ourselves to /bin/sh
-    for arg do
-        if
-            case $arg in                                #(
-              -*)   false ;;                             # don't mess with options #(
-              /?*)  t=${arg#/} t=/${t%%/*}                # looks like a POSIX filepath
-                    [ -e "$t" ] ;;                        #(
-              *)    false ;;
-            esac
-        then
-            arg=$( cygpath --path --ignore --mixed "$arg" )
-        fi
-        # Roll the args list around exactly as many times as the number of
-        # args, so each arg winds up back in the position where it started, but
-        # possibly modified.
-        #
-        # NB: a `for` loop captures its iteration list before it begins, so
-        # changing the positional parameters here affects neither the number of
-        # iterations, nor the values presented in `arg`.
-        shift                   # remove old arg
-        set -- "$@" "$arg"      # push replacement arg
-    done
-fi
-
-# Collect all arguments for the java command;
-#   * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments that
-#     shell script including quotes and variable substitutions, so put them in
-#     double quotes to make sure that they get re-expanded; and
-#   * put everything else in single quotes, so that it's not re-expanded.
-
-set -- \
-        "-Dorg.gradle.appname=$APP_BASE_NAME" \
-        -classpath "$CLASSPATH" \
-        org.gradle.wrapper.GradleWrapperMain \
-        "$@"
-
-# Stop when "xargs" is not available.
-if ! command -v xargs >/dev/null 2>&1
-then
-    die "xargs is not available"
-fi
-
-# Use "xargs" to parse quoted args.
-#
-# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
-#
-# In Bash we could simply go:
-#
-#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
-#   set -- "${ARGS[@]}" "$@"
-#
-# but POSIX shell has neither arrays nor command substitution, so instead we
-# post-process each arg (as a line of input to sed) to backslash-escape any
-# character that might be a shell metacharacter, then use eval to reverse
-# that process (while maintaining the separation between arguments), and wrap
-# the whole thing up as a single "set" statement.
-#
-# This will of course break if any of these variables contains a newline or
-# an unmatched quote.
-#
-
-eval "set -- $(
-        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
-        xargs -n1 |
-        sed ' s~[^-A-Za-z0-9_+.]~\\&~g; ' |
-        tr '\n' ' '
-    )" '"$@"'
-
-exec "$JAVACMD" "$@"
@@ -1,89 +0,0 @@
-@rem
-@rem Copyright 2015 the original author or authors.
-@rem
-@rem Licensed under the Apache License, Version 2.0 (the "License");
-@rem you may not use this file except in compliance with the License.
-@rem You may obtain a copy of the License at
-@rem
-@rem      https://www.apache.org/licenses/LICENSE-2.0
-@rem
-@rem Unless required by applicable law or agreed to in writing, software
-@rem distributed under the License is distributed on an "AS IS" BASIS,
-@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-@rem See the License for the specific language governing permissions and
-@rem limitations under the License.
-@rem
-
-@if "%DEBUG%"=="" @echo off
-@rem ##########################################################################
-@rem
-@rem  Gradle startup script for Windows
-@rem
-@rem ##########################################################################
-
-@rem Set local scope for the variables with windows NT shell
-if "%OS%"=="Windows_NT" setlocal
-
-set DIRNAME=%~dp0
-if "%DIRNAME%"=="" set DIRNAME=.
-@rem This is normally unused
-set APP_BASE_NAME=%~n0
-set APP_HOME=%DIRNAME%
-
-@rem Resolve any "." and ".." in APP_HOME to make it shorter.
-for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
-
-@rem Find java.exe
-if defined JAVA_HOME goto findJavaFromJavaHome
-
-set JAVA_EXE=java.exe
-%JAVA_EXE% -version >NUL 2>&1
-if %ERRORLEVEL% equ 0 goto execute
-
-echo. 1>&2
-echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
-echo. 1>&2
-echo Please set the JAVA_HOME variable in your environment to match the 1>&2
-echo location of your Java installation. 1>&2
-
-goto fail
-
-:findJavaFromJavaHome
-set JAVA_HOME=%JAVA_HOME:"=%
-set JAVA_EXE=%JAVA_HOME%/bin/java.exe
-
-if exist "%JAVA_EXE%" goto execute
-
-echo. 1>&2
-echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
-echo. 1>&2
-echo Please set the JAVA_HOME variable in your environment to match the 1>&2
-echo location of your Java installation. 1>&2
-
-goto fail
-
-:execute
-@rem Setup the command line
-
-set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
-
-
-@rem Execute Gradle
-"%JAVA_EXE%" -Dorg.gradle.appname=%APP_BASE_NAME% -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
-
-:end
-@rem End local scope for the variables with windows NT shell
-if %ERRORLEVEL% equ 0 goto mainEnd
-
-:fail
-rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
-rem the _cmd.exe /c_ return code!
-set EXIT_CODE=%ERRORLEVEL%
-if %EXIT_CODE% equ 0 set EXIT_CODE=1
-if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
-exit /b %EXIT_CODE%
-
-:mainEnd
-if "%OS%"=="Windows_NT" endlocal
-
-:omega
@@ -1,19 +0,0 @@
-pluginManagement {
-    repositories {
-        google()
-        mavenCentral()
-        gradlePluginPortal()
-    }
-}
-
-dependencyResolutionManagement {
-    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
-    repositories {
-        google()
-        mavenCentral()
-    }
-}
-
-rootProject.name = "Maestro"
-
-include(":app")
@@ -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
@@ -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()
@@ -1,514 +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");
-    let maestro_acp::AcpUpdate::Notification(first) = first else {
-        panic!("expected Notification");
-    };
-    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");
-        let maestro_acp::AcpUpdate::Notification(n) = update else {
-            continue;
-        };
-        if let SessionUpdate::ConfigOptionUpdate(options) = n.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(update: &maestro_acp::AcpUpdate) -> String {
-    let maestro_acp::AcpUpdate::Notification(n) = update else {
-        panic!("expected Notification, got {update:?}");
-    };
-    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());
-}
@@ -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"
-        );
-    }
 }
@@ -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,
 }
@@ -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(())
 }
@@ -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,6 @@ mod tests {
            current_cwd: None,
            blocked_work: None,
            last_focused_at: None,
-            acp_session_id: None,
-            auto_approve: false,
-            queued_prompts: Vec::new(),
        }
    }

@@ -378,22 +284,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);
@@ -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,6 @@ async fn info_carries_version_and_presets() {
            id: "claude".into(),
            label: "Claude".into(),
            command: "claude".into(),
-            auto_approve: false,
        }],
        ..Default::default()
    });
@@ -92,13 +91,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 +199,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;
@@ -313,19 +313,16 @@ pub fn builtin_presets() -> Vec<SpawnPreset> {
            id: "claude".into(),
            label: "Claude".into(),
            command: "claude".into(),
-            auto_approve: false,
        },
        SpawnPreset {
            id: "opencode".into(),
            label: "opencode".into(),
            command: "opencode".into(),
-            auto_approve: false,
        },
        SpawnPreset {
            id: "zsh".into(),
            label: "Shell".into(),
            command: "zsh".into(),
-            auto_approve: false,
        },
    ]
 }
@@ -337,7 +334,6 @@ pub fn custom_preset() -> SpawnPreset {
        id: CUSTOM_PRESET_ID.into(),
        label: "Custom…".into(),
        command: String::new(),
-        auto_approve: false,
    }
 }

@@ -519,7 +515,6 @@ auto_install = false
                id: "fish".into(),
                label: "fish".into(),
                command: "fish".into(),
-                auto_approve: false,
            }]),
            ..Default::default()
        };
@@ -556,7 +551,6 @@ auto_install = false
                id: "  ".into(),
                label: "x".into(),
                command: "x".into(),
-                auto_approve: false,
            }]),
            ..Default::default()
        };
@@ -567,7 +561,6 @@ auto_install = false
                id: "x".into(),
                label: "x".into(),
                command: "".into(),
-                auto_approve: false,
            }]),
            ..Default::default()
        };
@@ -585,13 +578,11 @@ auto_install = false
                    id: "a".into(),
                    label: "a".into(),
                    command: "a".into(),
-                    auto_approve: false,
                },
                SpawnPreset {
                    id: "a".into(),
                    label: "a2".into(),
                    command: "a2".into(),
-                    auto_approve: false,
                },
            ]),
            ..Default::default()
@@ -606,7 +597,6 @@ auto_install = false
                id: "custom".into(),
                label: "Custom".into(),
                command: "whatever".into(),
-                auto_approve: false,
            }]),
            ..Default::default()
        };
@@ -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"
@@ -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);
@@ -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
@@ -106,7 +100,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 +112,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)
@@ -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]
@@ -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);
    }
 }
@@ -21,7 +21,6 @@ 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;
@@ -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 {
@@ -67,20 +64,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 +164,12 @@ 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,
        _ => StatusCode::BAD_GATEWAY,
    }
 }
@@ -315,10 +297,11 @@ 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>,
@@ -385,198 +368,6 @@ 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 +405,12 @@ 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(_)) => {
-            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,
-            ));
-        }
+    let Some((replay, rx)) = s.manager.subscribe_pty_with_replay(id).await else {
+        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 +418,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)
 // ---------------------------------------------------------------------------
@@ -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"
-        );
-    }
-}
@@ -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> {
@@ -42,13 +42,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()
@@ -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();
@@ -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"));
-}
@@ -19,7 +19,6 @@ 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,
    }
 }

@@ -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.
@@ -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."}}}
@@ -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()
@@ -1255,7 +595,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 +604,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 +647,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 +656,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 +680,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 +715,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 +748,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 +780,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 +792,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");
@@ -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()
@@ -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,
        }
    }
 }
@@ -22,13 +22,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 +63,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 +92,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 +114,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 +140,140 @@ 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);
+}
+
+/// #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 +287,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 +295,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 +334,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 +343,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 +392,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 +400,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 +445,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 +507,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 +557,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 +622,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 +631,6 @@ async fn watcher_refreshes_the_blocked_work_indicator() {
                branch: "feat/indicator".into(),
                create_branch: true,
            }),
-            auto_approve: false,
        })
        .await
        .expect("create");
@@ -602,7 +714,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 +723,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 +751,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 +760,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 +814,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 +823,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 +863,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 +872,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 +908,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 +917,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 +948,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 +957,6 @@ async fn killing_an_ignored_only_worktree_succeeds() {
                branch: "feat/rusty".into(),
                create_branch: true,
            }),
-            auto_approve: false,
        })
        .await
        .expect("create");
@@ -889,7 +989,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 +998,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 +1050,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 +1059,6 @@ async fn natural_exit_of_a_pristine_worktree_removes_it() {
                branch: "feat/clean".into(),
                create_branch: true,
            }),
-            auto_approve: false,
        })
        .await
        .expect("create");
@@ -1014,13 +1110,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 +1144,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 +1153,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 +1161,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 +1170,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 +1199,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 +1237,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 +1262,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 +1310,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");
@@ -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,6 @@ 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(),
    }
 }

@@ -70,30 +66,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 +103,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 +113,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);
-}
@@ -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:
@@ -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`
@@ -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
@@ -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.
@@ -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;
@@ -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
@@ -196,29 +115,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 +173,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 +207,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 +236,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(
@@ -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");
@@ -212,10 +203,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 +221,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 +257,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 +298,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 +311,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 +321,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 +331,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 +350,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 +367,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 +436,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 +450,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 +459,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 +469,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());
 }
@@ -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
    }
@@ -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,6 @@ mod tests {
            current_cwd: None,
            blocked_work: None,
            last_focused_at: None,
-            acp_session_id: None,
-            auto_approve: false,
-            queued_prompts: Vec::new(),
        }
    }

@@ -957,132 +495,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);
    }
 }
@@ -116,43 +116,6 @@ 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.
-    #[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,
 }

 /// Default for [`Session::last_activity_at`] when an older payload omits it.
@@ -160,15 +123,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 +167,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 +189,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,
        })
@@ -240,10 +227,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 +380,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.
@@ -542,11 +519,6 @@ pub struct SpawnPreset {
    pub id: String,
    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,
 }

 /// Build provenance of the running daemon: the commit it was compiled
@@ -779,154 +751,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)
 // ---------------------------------------------------------------------------
@@ -1066,10 +890,6 @@ 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(),
        }
    }

@@ -1267,6 +1087,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 +1128,6 @@ mod tests {
                branch: "feat/foo".into(),
                create_branch: true,
            }),
-            view: SessionView::Terminal,
-            auto_approve: false,
        };
        assert_eq!(req, round_trip(&req));
    }
@@ -1297,74 +1142,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
@@ -71,41 +71,6 @@ 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 {
@@ -115,13 +80,6 @@ pub mod patterns {
    pub const SESSION_PROMPT: &str = "/api/sessions/:id/prompt";
    pub const SESSION_FOCUS: &str = "/api/sessions/:id/focus";
    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 +129,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 +178,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]
@@ -257,22 +206,6 @@ mod tests {
            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"
@@ -307,22 +240,6 @@ mod tests {
            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 +258,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));
    }
 }
@@ -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,6 @@ 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(),
    }
 }

@@ -63,8 +58,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 +90,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 +176,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 +264,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;
@@ -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

@@ -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,6 @@ mod tests {
                    current_cwd: None,
                    blocked_work: None,
                    last_focused_at: None,
-                    acp_session_id: None,
-                    auto_approve: false,
-                    queued_prompts: Vec::new(),
                })
                .collect(),
        });
@@ -2383,7 +2063,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 +2079,6 @@ mod tests {
                current_cwd: None,
                blocked_work: None,
                last_focused_at: None,
-                acp_session_id: None,
-                auto_approve: false,
-                queued_prompts: Vec::new(),
            }],
        });
        app.dispatch(Action::SidebarNext);
@@ -2414,7 +2090,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 +2106,6 @@ mod tests {
            current_cwd: None,
            blocked_work: None,
            last_focused_at: None,
-            acp_session_id: None,
-            auto_approve: false,
-            queued_prompts: Vec::new(),
        }
    }

@@ -3105,13 +2777,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 +2798,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 +3195,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 +3214,6 @@ mod tests {
            current_cwd: None,
            blocked_work: None,
            last_focused_at: focused,
-            acp_session_id: None,
-            auto_approve: false,
-            queued_prompts: Vec::new(),
        };
        let older = Utc::now() - chrono::Duration::seconds(60);
        app.catalog.apply_event(CatalogEvent::Snapshot {
@@ -3859,7 +3475,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 +3492,6 @@ mod tests {
                current_cwd: None,
                blocked_work: None,
                last_focused_at: None,
-                acp_session_id: None,
-                auto_approve: false,
-                queued_prompts: Vec::new(),
            }],
        });
        app.dispatch(Action::KillHighlighted);
@@ -3899,7 +3511,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 +3527,6 @@ mod tests {
                current_cwd: None,
                blocked_work: None,
                last_focused_at: None,
-                acp_session_id: None,
-                auto_approve: false,
-                queued_prompts: Vec::new(),
            }],
        });
    }
@@ -4076,112 +3684,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
-        );
-    }
 }
@@ -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,6 @@ mod tests {
            current_cwd: None,
            blocked_work: None,
            last_focused_at: None,
-            acp_session_id: None,
-            auto_approve: false,
-            queued_prompts: Vec::new(),
        }
    }

@@ -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,6 @@ mod tests {
            current_cwd: None,
            blocked_work: None,
            last_focused_at: None,
-            acp_session_id: None,
-            auto_approve: false,
-            queued_prompts: Vec::new(),
        }
    }

@@ -893,6 +891,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(
--- a/Show More
+++ b/Show More